亚马逊 Sagemaker 学习指南第二版（一）

最新推荐文章于 2025-09-01 10:58:35 发布

原创最新推荐文章于 2025-09-01 10:58:35 发布 · 595 阅读

8 ·

CC 4.0 BY-SA版权

License CC BY-NC-SA 4.0 / 自豪地采用谷歌翻译

文章标签：

#默认分类

默认分类专栏收录该内容

10503 篇文章

订阅专栏

部署运行你感兴趣的模型镜像

原文：annas-archive.org/md5/9ea32aa91e5ec8d38bb57552873cedb5

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Amazon SageMaker 使你能够在不管理任何基础设施的情况下，快速构建、训练和部署大规模的机器学习模型。它帮助你专注于当前的机器学习问题，并通过消除每个 ML 过程步骤中通常涉及的繁重工作来部署高质量的模型。第二版将帮助数据科学家和机器学习开发人员探索新功能，如 SageMaker Data Wrangler、Pipelines、Clarify、Feature Store 等等。

你将从学习如何使用 SageMaker 的各种功能作为一个单一工具集来解决 ML 挑战开始，逐步涵盖 AutoML、内置算法和框架等功能，以及编写你自己的代码和算法来构建 ML 模型。本书随后将向你展示如何将 Amazon SageMaker 与流行的深度学习库（如 TensorFlow 和 PyTorch）集成，以扩展现有模型的功能。你将看到如何通过自动化工作流程，以最小的努力和更低的成本更快地进入生产阶段。最后，你将探索 SageMaker Debugger 和 SageMaker Model Monitor，以检测训练和生产中的质量问题。

本书结束时，你将能够在整个机器学习工作流程中使用 Amazon SageMaker，从实验、训练、监控到扩展、部署和自动化。

本书适用对象

本书适合软件工程师、机器学习开发人员、数据科学家以及那些刚接触 Amazon SageMaker 的 AWS 用户，帮助他们在无需担心基础设施的情况下构建高质量的机器学习模型。为了更有效地理解本书中涉及的概念，读者需要具备一定的 AWS 基础知识。对机器学习概念和 Python 编程语言的扎实理解也将大有裨益。

本书内容

第一章，介绍 Amazon SageMaker，提供了 Amazon SageMaker 的概述，介绍了它的功能以及它如何帮助解决今天机器学习项目中面临的许多痛点。

第二章，处理数据准备技术，讨论了数据准备选项。虽然这不是本书的核心内容，但数据准备是机器学习中的一个关键话题，值得在高层次上进行探讨。

第三章，使用 Amazon SageMaker AutoPilot 进行 AutoML，展示了如何通过 Amazon SageMaker AutoPilot 自动构建、训练和优化机器学习模型。

第四章，训练机器学习模型，展示了如何使用 Amazon SageMaker 中内置的统计机器学习算法集合来构建和训练模型。

第五章，训练计算机视觉模型，展示了如何使用 Amazon SageMaker 中内置的计算机视觉算法集合来构建和训练模型。

第六章，训练自然语言处理模型，展示了如何使用 Amazon SageMaker 中内置的自然语言处理算法集合来构建和训练模型。

第七章，使用内置框架扩展机器学习服务，展示了如何利用 Amazon SageMaker 中内置的开源框架集合来构建和训练机器学习模型。

第八章，使用你的算法和代码，展示了如何在 Amazon SageMaker 上使用自己的代码（例如 R 或自定义 Python）构建和训练机器学习模型。

第九章，扩展训练任务，展示了如何将训练任务分发到多个托管实例，无论是使用内置算法还是内置框架。

第十章，高级训练技巧，展示了如何在 Amazon SageMaker 中利用高级训练技巧。

第十一章，部署机器学习模型，展示了如何以多种配置部署机器学习模型。

第十二章，自动化机器学习工作流，展示了如何在 Amazon SageMaker 上自动化机器学习模型的部署。

第十三章，优化成本和性能，展示了如何从基础设施和成本两个角度来优化模型部署。

要充分利用本书内容

你需要一个可用的 AWS 账户来运行所有内容。

如果你使用的是本书的数字版，建议你自己输入代码，或者通过 GitHub 仓库访问代码（链接将在下一节提供）。这样做有助于避免由于复制粘贴代码而产生的潜在错误。

下载示例代码文件

你可以从www.packt.com的账户中下载本书的示例代码文件。如果你在其他地方购买了本书，你可以访问www.packtpub.com/support并注册，以便直接将文件发送到你的邮箱。

你可以按照以下步骤下载代码文件：

登录或注册到www.packt.com。
选择支持标签。
点击代码下载。
在搜索框中输入书名，并按照屏幕上的指示操作。

文件下载完成后，请确保使用以下最新版本解压或提取文件夹：

WinRAR/7-Zip for Windows
Zipeg/iZip/UnRarX for Mac
适用于 Linux 的 7-Zip/PeaZip

本书的代码包也托管在 GitHub 上，地址为 github.com/PacktPublishing/Learn-Amazon-SageMaker-second-edition。如果代码有更新，它将同步更新到现有的 GitHub 仓库中。

我们还提供了来自我们丰富图书和视频目录的其他代码包，网址为 github.com/PacktPublishing/。快来看看吧！

下载彩色图片

我们还提供了一个包含本书中使用的截图/图表的彩色图片 PDF 文件。你可以在这里下载：static.packt-cdn.com/downloads/9781801817950_ColorImages.pdf。

使用的约定

本书中使用了多种文本约定。

文中的代码：指示文本中的代码词汇、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟网址、用户输入和 Twitter 账号。这里是一个例子：“你可以使用 describe-spot-price-history API 来编程收集这些信息。”

一段代码的格式如下：

od = sagemaker.estimator.Estimator(     container,     role,     train_instance_count=2,                                      train_instance_type='ml.p3.2xlarge',                                      train_use_spot_instances=True,     train_max_run=3600,                     # 1 hours      train_max_wait=7200,                    # 2 hour      output_path=s3_output)

当我们希望特别提醒你注意代码块中的某一部分时，相关的行或项目会以粗体显示：

[<sagemaker.model_monitor.model_monitoring.MonitoringExecution at 0x7fdd1d55a6d8>,<sagemaker.model_monitor.model_monitoring.MonitoringExecution at 0x7fdd1d581630>,<sagemaker.model_monitor.model_monitoring.MonitoringExecution at 0x7fdce4b1c860>]

粗体：表示一个新术语、一个重要的词汇，或屏幕上显示的词语。例如，菜单或对话框中的词汇会像这样出现在文本中。这里是一个例子：“我们可以在 SageMaker 控制台的 Processing jobs 部分找到更多关于监控任务的信息。”

提示或重要说明

显示如图所示。

联系我们

我们始终欢迎读者的反馈。

customercare@packtpub.com。

勘误：尽管我们已尽力确保内容的准确性，但错误难免。如果你发现本书中有任何错误，我们将非常感激你能向我们报告。请访问 www.packtpub.com/support/errata，选择你的书籍，点击“勘误提交表格”链接，并输入相关细节。

copyright@packt.com 并附有相关材料的链接。

如果你有兴趣成为一名作者：如果你在某个领域有专业知识，并且有兴趣撰写或贡献一本书，请访问 authors.packtpub.com。

分享你的想法

阅读完 Learn Amazon Sagemaker, Second Edition 后，我们希望听到你的想法！请点击此处直接前往该书的 Amazon 评价页面，分享你的反馈。

你的评论对我们以及技术社区非常重要，将帮助我们确保提供优质内容。

第一部分：介绍 Amazon SageMaker

本节的目标是向你介绍关键概念，帮助你下载支持数据，并向你展示示例场景和使用案例。

本节包括以下章节：

第一章，介绍 Amazon SageMaker
第二章，处理数据准备技巧

第一章：介绍亚马逊 SageMaker

机器学习（ML）从业者在项目过程中使用大量工具：开源库、深度学习框架等。此外，他们还经常需要编写自己的工具来进行自动化和编排。管理这些工具及其底层基础设施既耗时又容易出错。

这是亚马逊 SageMaker 旨在解决的一个问题（aws.amazon.com/sagemaker/）。亚马逊 SageMaker 是一个完全托管的服务，帮助你快速构建和部署机器学习模型。无论你是刚开始接触机器学习，还是已经是经验丰富的从业者，你都能找到 SageMaker 的功能来提高工作流的灵活性和模型的性能。你将能够 100%专注于当前的机器学习问题，而无需花费任何时间来安装、管理和扩展机器学习工具和基础设施。

在本章中，我们将学习 SageMaker 的主要功能，它们如何帮助解决机器学习从业者面临的痛点，以及如何设置 SageMaker。本章将涵盖以下主题：

探索亚马逊 SageMaker 的功能
在本地机器上设置亚马逊 SageMaker
设置亚马逊 SageMaker Studio
使用亚马逊 SageMaker JumpStart 部署一键解决方案和模型

技术要求

你需要一个 AWS 账户来运行本章中的示例。如果你还没有账户，请在浏览器中访问aws.amazon.com/getting-started/，了解 AWS 及其核心概念，并创建一个 AWS 账户。你还应该熟悉 AWS Free Tier（aws.amazon.com/free/），它让你在一定的使用限制内免费使用许多 AWS 服务。

你需要为你的账户安装并配置 AWS CLI（aws.amazon.com/cli/）。

你需要一个可用的 Python 3.x 环境。安装 Anaconda 发行版（www.anaconda.com/）不是强制性的，但强烈推荐安装，因为它包含了我们需要的许多项目（Jupyter、pandas、numpy等）。

本书中的代码示例可以在 GitHub 上找到：github.com/PacktPublishing/Learn-Amazon-SageMaker-second-edition。你需要安装一个 Git 客户端才能访问它们（git-scm.com/）。

探索亚马逊 SageMaker 的功能

Amazon SageMaker 于 2017 年 AWS re:Invent 大会推出。自那时以来，添加了许多新功能：你可以在 aws.amazon.com/about-aws/whats-new/machine-learning 上查看完整的（且不断增长的）功能列表。

在本节中，你将了解 Amazon SageMaker 的主要功能及其目的。别担心，我们会在后续章节深入探讨每一个功能。我们还会讨论实现这些功能的 SageMaker 应用程序 编程接口（APIs）和软件开发 工具包（SDKs）。

Amazon SageMaker 的主要功能

Amazon SageMaker 的核心功能是能够在完全托管的基础设施上，按需准备、构建、训练、优化和部署模型。这让你可以专注于学习和解决手头的机器学习问题，而不是花费时间和资源在构建和管理基础设施上。简而言之，你可以更快地从构建到训练再到部署。接下来，我们将深入探讨每个步骤，并突出相关的 SageMaker 功能。

准备工作

Amazon SageMaker 包含强大的工具来标注和准备数据集：

Amazon SageMaker Ground Truth：在任何规模上标注数据集。内置了适用于流行用例的工作流（如图像检测、实体提取等），并且你可以实现自己的工作流。标注任务可以分配给属于私人、第三方或公共劳动力的工作人员。
Amazon SageMaker Processing：使用你用 scikit-learn 或 Spark 编写的代码，运行批处理作业进行数据处理（以及其他任务，如模型评估）。
Amazon SageMaker Data Wrangler：通过图形界面，将数百种内建的转换（或你自己的转换）应用到表格数据集，并通过一键操作将其导出到 Jupyter 笔记本中。
Amazon SageMaker 特征存储：将你的工程特征存储在 Amazon S3 中，用于离线构建数据集，或在线使用它们进行预测。
Amazon SageMaker Clarify：通过多种统计指标，分析数据集和模型中潜在的偏差，并解释模型如何进行预测。

构建

Amazon SageMaker 提供了两种开发环境：

Notebook 实例：完全托管的 Amazon EC2 实例，预装了最流行的工具和库：Jupyter、Anaconda 等。
Amazon SageMaker Studio：一个端到端的集成开发环境，专为机器学习项目设计，提供直观的图形界面，支持许多 SageMaker 功能。Studio 现在是运行笔记本的首选方式，我们建议你使用它，而非笔记本实例。

在实验算法时，你可以选择以下选项：

提供 17 种内建算法，用于机器学习和深度学习，已经实现并优化以便在 AWS 上高效运行。无需编写机器学习代码！
内置的开源框架集合（TensorFlow、PyTorch、Apache MXNet、scikit-learn 等），您只需带上自己的代码。
在您自己的容器中运行您自己的代码：自定义 Python、R、C++、Java 等。
来自 AWS Marketplace 的算法和预训练模型，适用于机器学习（aws.amazon.com/marketplace/solutions/machine-learning）。
机器学习解决方案和先进的模型可通过 Amazon SageMaker JumpStart 一键获得。

此外，Amazon SageMaker Autopilot 利用自动机器学习（AutoML）自动构建、训练和优化模型，无需编写一行机器学习代码。

训练

如前所述，Amazon SageMaker 负责配置和管理您的训练基础设施。您将不再浪费时间管理服务器，专注于机器学习。同时，SageMaker 提供了如下一些先进功能：

托管存储，可以选择 Amazon S3、Amazon EFS 或 Amazon FSx for Lustre，具体取决于您的性能需求。
托管竞价训练，使用 Amazon EC2 Spot 实例进行训练，从而节省高达 80% 的成本。
分布式训练 自动将大规模训练作业分配到一组托管实例，采用数据并行和模型并行等先进技术。
Pipe mode 将超大数据集从 Amazon S3 流式传输到训练实例，省去了复制数据的需求。
自动模型调优 运行超参数优化，更快速地交付高精度模型。
Amazon SageMaker Experiments 轻松跟踪、组织和比较所有的 SageMaker 作业。
Amazon SageMaker Debugger 在训练过程中捕获内部模型状态，检查其以观察模型的学习方式，检测会影响准确性的非理想条件，并分析训练作业的性能。

部署

与训练一样，Amazon SageMaker 会处理所有部署基础设施，并提供一系列附加功能：

实时终端 创建一个 HTTPS API，从您的模型中提供预测。正如您所期望的那样，自动扩展是可用的。
Batch transform 使用模型批量预测数据。
Amazon Elastic Inference 为基于 CPU 的终端提供分数级 GPU 加速，以找到最佳的成本/性能比，用于您的预测基础设施。
Amazon SageMaker Model Monitor 捕获发送到终端的数据，并与基准数据进行比较，识别并报警数据质量问题（缺失特征、数据漂移等）。
Amazon SageMaker Neo 为特定硬件架构（包括嵌入式平台）编译模型，并使用轻量级运行时部署优化版本。
Amazon SageMaker Edge Manager 帮助您在边缘设备上部署和管理模型。
最后但同样重要的是，Amazon SageMaker Pipelines 允许你构建端到端的自动化流水线，以运行和管理数据准备、训练和部署工作负载。

Amazon SageMaker API

就像所有其他 AWS 服务一样，Amazon SageMaker 由 API 驱动，这些 API 被实现于 AWS 支持的语言 SDK 中 (aws.amazon.com/tools/)。此外，还提供了一个专门的 Python SDK，即 SageMaker SDK。让我们来看看这两者，并讨论它们各自的优点。

AWS 语言 SDK

语言 SDK 实现了所有 AWS 服务的特定 API：S3、EC2 等。当然，它们也包含了 SageMaker API，相关文档可以在这里查看：docs.aws.amazon.com/sagemaker/latest/dg/api-and-sdk-reference.htma机器学习。

在数据科学和机器学习领域，Python 是最受欢迎的语言，因此让我们来看一下在 boto3 中可用的 SageMaker API，它是 AWS 为 Python 语言提供的 SDK (boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.htma机器学习)。这些 API 相当底层且冗长：例如，create_training_job() 有许多看起来不太直观的 JSON 参数。你可以在下一个截图中看到其中一些。你可能会觉得这对于日常的机器学习实验来说并不太吸引人……我完全同意！

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_001.jpg

图 1.1 – boto3 中 create_training_job() API 的（部分）视图

事实上，这些服务级别的 API 并不适用于在笔记本中进行实验。它们的目的是自动化，通过定制脚本或基础设施即代码工具，如 AWS CloudFormation (aws.amazon.com/cloudformation) 和 Terraform (terraform.io)。你的 DevOps 团队将使用这些工具来管理生产环境，因为他们需要对每个可能的参数拥有完全控制权。

那么，应该使用什么来进行实验呢？你应该使用 Amazon SageMaker SDK。

Amazon SageMaker SDK

Amazon SageMaker SDK (github.com/aws/sagemaker-python-sdk) 是一个专为 Amazon SageMaker 提供的 Python SDK。你可以在 sagemaker.readthedocs.io/en/stable/ 找到它的文档。

注意

本书中的代码示例已经尽最大努力与最新的 SageMaker SDK（截至撰写时为 v2.58.0）进行过检查。

在这里，抽象层次要高得多：SDK 包含了用于模型、估算器、预测器等的对象。我们无疑已经回到了机器学习的领域。

例如，这个 SDK 使得启动训练作业（一行代码）和部署模型（一行代码）变得非常简单和方便。基础设施问题被抽象化，我们可以专注于机器学习。这里有一个例子。现在不用担心细节：

# Configure the training job
my_estimator = TensorFlow(
    entry_point='my_script.py',
    role=my_sagemaker_role,
    train_instance_type='machine learning.p3.2xlarge',
    instance_count=1,
    framework_version='2.1.0')
# Train the model
my_estimator.fit('s3://my_bucket/my_training_data/')
# Deploy the model to an HTTPS endpoint
my_predictor = my_estimator.deploy(
    initial_instance_count=1, 
    instance_type='machine learning.c5.2xlarge')

现在我们对 Amazon SageMaker 有了一些了解，让我们看看如何设置它。

在本地机器上设置 Amazon SageMaker

一个常见的误解是你不能在 AWS 云之外使用 SageMaker。显然，它是一个基于云的服务，其最吸引人的功能需要云基础设施来运行。然而，许多开发人员喜欢按照自己的方式设置开发环境，SageMaker 让他们可以做到：在本节中，您将学习如何在本地机器或本地服务器上安装 SageMaker SDK。在后面的章节中，您将学习如何在本地训练和部署模型。

最好的做法是隔离 Python 环境以避免依赖地狱。让我们看看如何使用两个流行项目virtualenv（virtualenv.pypa.io）和 Anaconda（www.anaconda.com/）来实现这一点。

使用 virtualenv 安装 SageMaker SDK

如果你以前从未使用过virtualenv，请在继续之前阅读本教程：packaging.python.org/guides/installing-using-pip-and-virtual-environments/：

首先，让我们创建一个名为sagemaker的新环境并激活它：

$ mkdir workdir
$ cd workdir
$ python3 -m venv sagemaker
$ source sagemaker/bin/activate

现在，让我们安装boto3，SageMaker SDK 和pandas库（pandas.pydata.org/）：
```
$ pip3 install boto3 sagemaker pandas
```

现在，让我们快速检查我们是否可以将这些 SDK 导入 Python：

$ python3
Python 3.9.5 (default, May  4 2021, 03:29:30)
>>> import boto3
>>> import sagemaker
>>> print(boto3.__version__)
1.17.70
>>> print(sagemaker.__version__)
2.39.1
>>> exit()

安装看起来很好。你自己的版本肯定会更新，这没问题。现在，让我们通过本地 Jupyter 服务器（jupyter.org/）运行一个快速测试。如果你的机器上没有安装 Jupyter，你可以在jupyter.org/install找到说明：

首先，让我们基于我们的虚拟环境创建一个 Jupyter 内核：

$ pip3 install jupyter ipykernel
$ python3 -m ipykernel install --user --name=sagemaker

然后，我们可以启动 Jupyter：
```
$ jupyter notebook
```
创建一个新的笔记本，我们可以看到sagemaker内核是可用的，所以让我们在新建菜单中选择它，如下截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_002.jpg

图 1.2 – 创建一个新的笔记本
最后，我们可以通过导入它们并打印它们的版本来检查 SDK 是否可用，如下截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_003.jpg

图 1.3 – 检查 SDK 版本

这样就完成了使用virtualenv的安装。不要忘记终止 Jupyter，并且取消激活你的virtualenv：

$ deactivate

你也可以使用 Anaconda 安装 SDK。

使用 Anaconda 安装 SageMaker SDK

conda允许你创建和管理隔离的环境。如果你之前从未使用过conda，你应该做以下操作：

安装 Anaconda：docs.anaconda.com/anaconda/install/。
阅读这个教程：docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html。

我们将通过以下步骤开始：

创建并激活一个名为conda-sagemaker的新conda环境：

$ conda create -y -n conda-sagemaker
$ conda activate conda-sagemaker

然后，我们安装pandas、boto3和 SageMaker SDK。后者必须使用pip安装，因为它不是conda包：
```
$ conda install -y boto3 pandas
$ pip3 install sagemaker
```

现在，让我们将 Jupyter 及其依赖项添加到环境中，并创建一个新的内核：

$ conda install -y jupyter ipykernel
$ python3 -m ipykernel install --user --name conda-sagemaker

然后，我们可以启动 Jupyter：

conda-sagemaker kernel is present in the New menu, as is visible in the following screenshot:<https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_004.jpg>

就像上一节中一样，我们可以使用这个内核创建一个笔记本，并检查 SDK 是否正确导入。

这完成了使用conda的安装。你是否选择使用conda而不是virtualenv，主要是个人偏好的问题。你完全可以使用其中任意一个来运行本书中的所有笔记本并构建你自己的项目。

关于 AWS 权限的说明

Amazon 身份与访问管理（IAM）使你能够安全地管理对 AWS 服务和资源的访问（aws.amazon.com/iam）。当然，这也适用于 Amazon SageMaker，你需要确保你的 AWS 用户有足够的权限来调用 SageMaker API。

IAM 权限

如果你完全不熟悉 IAM，请阅读以下文档：

docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html。

你可以通过使用 AWS CLI 调用一个 SageMaker API（例如，list-endpoints）来快速测试。我这里使用的是eu-west-1区域，但你也可以使用离你最近的区域：

$ aws sagemaker list-endpoints --region eu-west-1
{
    "Endpoints": []
}

如果你收到权限不足的错误信息，你需要更新与你的 AWS 用户关联的 IAM 角色。

如果你拥有相关的 AWS 账户，你可以在 IAM 控制台中轻松地通过将AmazonSageMakerFullAccess托管策略添加到你的角色中来完成这项工作。请注意，这个策略权限非常宽松：对于开发账户来说没问题，但对于生产账户来说肯定不行。

如果你使用的账户没有管理员权限（例如公司提供的账户），请联系你的 IT 管理员为你的 AWS 用户添加 SageMaker 权限。

有关 SageMaker 权限的更多信息，请参阅文档：docs.aws.amazon.com/sagemaker/latest/dg/security-iam.html。

设置 Amazon SageMaker Studio

实验是机器学习过程中的关键部分。开发人员和数据科学家使用一系列开源工具和库进行数据探索、数据处理，当然还有评估候选算法。安装和维护这些工具需要花费大量时间，而这些时间可能更好地用来研究机器学习问题本身！

Amazon SageMaker Studio 为你提供从实验到生产所需的机器学习工具。其核心是基于 Jupyter 的集成开发环境，使你可以立即上手。

此外，SageMaker Studio 与其他 SageMaker 功能集成，例如 SageMaker 实验，用于跟踪和比较所有任务，SageMaker Autopilot 用于自动创建机器学习模型等等。很多操作只需几次点击就能完成，无需编写任何代码。

SageMaker Studio 还进一步简化了基础设施管理。你无需创建笔记本实例：SageMaker Studio 为你提供了现成的计算环境，随时可以运行你的笔记本。

注意

本节需要具备 Amazon S3、Amazon VPC 和 Amazon IAM 的基本知识。如果你对这些完全不熟悉，请阅读以下文档：

docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.htma机器学习

docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.htma机器学习

docs.aws.amazon.com/IAM/latest/UserGuide/introduction.htma机器学习

现在也许是时候查看（并收藏）SageMaker 定价页面：aws.amazon.com/sagemaker/pricing/。

入职 Amazon SageMaker Studio

你可以通过以下三种方式之一访问 SageMaker Studio：

使用快速入门流程：这是个人账户最简单的选择，我们将在接下来的段落中详细介绍。
使用 AWS 单点登录（SSO）：如果你的公司已经设置了 SSO 应用程序，这可能是最好的选择。你可以通过docs.aws.amazon.com/sagemaker/latest/dg/onboard-sso-users.htma了解更多关于 SSO 入职的信息。请联系你的 IT 管理员获取详细信息。
使用 Amazon IAM：如果你的公司不使用 SSO，这可能是最好的选择。你可以通过docs.aws.amazon.com/sagemaker/latest/dg/onboard-iam.htma了解更多关于 SSO 入职的信息。再次提醒，请联系你的 IT 管理员了解更多细节。

使用快速入门流程进行入职

快速入门流程包含几个步骤：

首先，在 Amazon SageMaker Studio 可用的某个地区打开 AWS 控制台，例如，us-east-2.console.aws.amazon.com/sagemaker/。
如下图所示，左侧的垂直面板中有一个链接到SageMaker Studio：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_005.jpg

图 1.5 – 打开 SageMaker Studio
点击这个链接会打开入门界面，你可以在下一个截图中看到它的第一部分：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_006.jpg

图 1.6 – 运行快速入门
选择快速入门。然后，输入我们希望用于登录 SageMaker Studio 的用户名，并按照前面截图中的说明创建一个新的 IAM 角色。接下来会打开以下界面：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_007.jpg

图 1.7 – 创建 IAM 角色

我们需要做的唯一决策是是否允许我们的笔记本实例访问特定的 Amazon S3 存储桶。选择任何 S3 存储桶并点击创建角色。这是开发和测试中最灵活的设置，但在生产环境中我们会希望应用更严格的设置。当然，我们可以稍后在 IAM 控制台中编辑这个角色，或者创建一个新的角色。
一旦点击创建角色，我们就会回到之前的界面。请确保该账户启用了项目模板和 JumpStart。（这应该是默认设置）。
我们只需要点击提交来启动入门程序。根据你的账户设置，可能会出现一个额外的界面，要求你选择一个 VPC 和子网。我建议选择你默认 VPC 中的任何子网。
几分钟后，SageMaker Studio 开始服务，如下图所示。我们如果需要可以添加额外的用户，但现在只需点击打开 Studio：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_008.jpg

图 1.8 – 启动 SageMaker Studio

如果这需要再多等几分钟也不要担心，因为 SageMaker Studio 需要完成第一次运行环境的设置。如下图所示，一旦我们打开 SageMaker Studio，我们会看到熟悉的 JupyterLab 界面：

注意

SageMaker Studio 是一个不断发展的平台。当你阅读这篇文章时，某些界面可能已经更新。此外，你可能会注意到不同地区之间存在一些小差异，因为某些功能或实例类型在某些地区可能不可用。

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_009.jpg

图 1.9 – SageMaker Studio 欢迎界面
我们可以立即创建我们的第一个笔记本。在启动器标签页的笔记本和计算资源部分，选择数据科学，然后点击笔记本 – Python 3。
这会打开一个笔记本，如下图所示。我们首先检查 SDK 是否已准备好。由于这是我们第一次启动 数据科学 内核，我们需要等待几分钟。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_010.jpg

图 1.10 – 检查 SDK 版本
如下图所示，我们可以轻松列出当前在 Studio 实例中运行的资源：一个 机器学习.t3.medium 实例、支持笔记本内核的数据科学镜像，以及笔记本本身：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_011.jpg

图 1.11 – 查看 Studio 资源
为了避免不必要的费用，我们应该在完成工作后关闭这些资源。例如，我们可以关闭实例和它上面运行的所有资源，正如下面的截图所示。现在不要关闭，我们需要这个实例来运行接下来的示例！！图 1.12 – 关闭实例

图 1.12 – 关闭实例
机器学习.t3.medium 是 Studio 使用的默认实例类型。你可以通过点击笔记本顶部的 2 vCPU + 4 GiB 切换到其他实例类型。这样可以选择新的实例类型并在 Studio 中启动它。几分钟后，实例就启动了，你的笔记本代码也会自动迁移。别忘了关闭之前的实例，正如前面所解释的那样。
当我们完成与 SageMaker Studio 的工作时，所要做的就是关闭浏览器标签。如果我们想要继续工作，只需返回到 SageMaker 控制台并点击 打开 Studio。
如果我们想关闭 Studio 实例本身，只需在文件菜单中选择关闭。所有文件会被保留，直到我们在 SageMaker 控制台中完全删除 Studio。

现在我们已经完成了设置，我相信你迫不及待地想开始进行机器学习了。让我们开始部署一些模型吧！

使用 Amazon SageMaker JumpStart 部署一键解决方案和模型

如果你是机器学习的新手，可能会发现很难开始实际项目。你已经运行了所有的玩具示例，也读了几篇关于计算机视觉或自然语言处理模型的博客。那么接下来该怎么办？如何将这些复杂的模型应用到你自己的数据上，解决你自己的业务问题？

即使你是经验丰富的从业者，构建端到端的机器学习解决方案也不是一项简单的任务。训练和部署模型只是其中的一部分：数据准备、自动化等怎么办？

Amazon SageMaker JumpStart 是专门为帮助每个人更快速地开始机器学习项目而构建的。只需点击一次，你就可以部署以下内容：

16 个端到端的解决方案，涵盖实际业务问题，如金融交易中的欺诈检测、信用决策解释、预测性维护等
超过 180 个预先训练的 TensorFlow 和 PyTorch 模型，涵盖各种计算机视觉和自然语言处理任务
额外的学习资源，如示例笔记本、博客文章和视频教程

到了部署解决方案的时候了。

部署解决方案

让我们开始：

从左侧图标栏开始，我们打开 JumpStart。以下截图显示了启动屏幕：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_013.jpg

图 1.13 – 在 JumpStart 中查看解决方案
选择金融交易中的欺诈检测。如以下截图所示，这是一个使用图数据和图神经网络基于交互预测欺诈活动的精彩示例：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_014.jpg

图 1.14 – 查看解决方案详情
阅读完解决方案详情后，我们只需点击启动按钮。这将运行一个 AWS CloudFormation 模板，负责构建解决方案所需的所有 AWS 资源。

CloudFormation

如果你对 CloudFormation 感兴趣，你可以参考这个介绍：docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.htma机器学习。
几分钟后，解决方案准备就绪，如以下截图所示。我们点击打开笔记本来打开第一个笔记本。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_015.jpg

图 1.15 – 打开解决方案
如以下截图所示，我们可以在左侧面板浏览解决方案文件：笔记本、训练代码等：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_016.jpg

图 1.16 – 查看解决方案文件
从此时起，你可以开始运行并调整笔记本。如果你还不熟悉 SageMaker SDK，也无需担心细节。
完成后，请返回解决方案页面并点击删除所有资源，以清理并避免不必要的费用，如以下截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_017.jpg

图 1.17 – 删除解决方案

如你所见，JumpStart 解决方案是探索如何使用机器学习解决业务问题的绝佳方式，并开始思考如何在自己的业务环境中实现相同的目标。

现在，让我们看看如何部署预训练模型。

部署模型

JumpStart 包括超过 180 个预先训练的 TensorFlow 和 PyTorch 模型，涵盖各种计算机视觉和自然语言处理任务。让我们来看一下计算机视觉模型：

从 JumpStart 主屏幕开始，我们打开视觉模型，如以下截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_018.jpg

图 1.18 – 查看计算机视觉模型
假设我们有兴趣尝试基于 单次检测器（SSD）架构的物体检测模型。我们点击 PyTorch Hub 上的 SSD 模型（从左数第四个）。
这将打开模型详细信息页面，告诉我们模型的来源、训练使用的数据集以及它可以预测的标签。我们还可以选择部署模型的实例类型。保持默认设置后，我们点击部署将模型部署到实时端点，如以下截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_019.jpg

图 1.19 – 部署 JumpStart 模型
几分钟后，模型已经部署。如以下截图所示，我们可以在左侧面板看到端点状态，点击 打开 Notebook 即可进行测试。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_020.jpg

图 1.20 – 打开 JumpStart Notebook
通过点击 Notebook 单元格，我们下载了一张测试图像，并预测其中包含的对象。以下截图显示了边界框、类别和概率：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_021.jpg

图 1.21 – 在图片中检测物体
完成后，请确保删除端点以避免不必要的费用：只需在 图 1.20 显示的端点详细信息屏幕上点击删除。

JumpStart 不仅让你轻松尝试最先进的模型，还提供了可以直接用于自己项目的代码：加载图像进行预测、使用端点进行预测、绘制结果等等。

尽管预训练模型非常有用，但我们通常需要在自己的数据集上对其进行微调。让我们看看如何使用 JumpStart 来实现这一点。

微调模型

这次我们使用一个图像分类模型：

注意

关于微调文本模型的警告：像 BERT 这样的复杂模型微调可能需要很长时间，甚至在单个 GPU 上每个 epoch 需要几个小时。除了长时间的等待，成本也不会忽视，因此除非你有一个实际的商业项目，否则我建议避免这些例子。

我们选择了 Resnet 18 模型（如 图 1.18 中第二个从左的模型）。
在模型详细信息页面，我们可以看到该模型可以在默认的数据集上进行微调，该数据集用于测试（一个包含五种花卉类别的 TensorFlow 数据集），或者在我们存储在 S3 中的数据集上进行微调。向下滚动，我们了解了数据集应具有的格式。
如下图所示，我们选择了默认数据集。我们还保持了部署配置和训练参数不变。然后，我们点击训练启动微调任务。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_022.jpg

图 1.22 – 微调模型
仅需几分钟，微调就完成了（这就是我选择这个例子的原因！）。我们可以看到微调模型存储在 S3 中的输出路径。让我们记下这个路径，稍后我们会用到它。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_01_023.jpg

图 1.23 – 查看微调结果
然后，我们像之前的例子一样点击 Deploy。模型部署完成后，我们打开示范笔记本，展示如何使用初始的预训练模型进行预测。
这个笔记本使用了模型预训练时所用的原始数据集中的图像。没问题，让我们来适应它！即使我们还不熟悉 SageMaker SDK，笔记本也足够简单，我们可以理解发生了什么，并添加几个单元格，用我们的微调模型预测一张花卉图片。

首先，我们添加一个单元格，从 S3 复制微调后的模型工件，并提取 JumpStart 添加的类别列表和类别索引：

%%sh
aws s3 cp s3://sagemaker-REGION_NAME-123456789012/smjs-d-pt-ic-resnet18-20210511-142657/output/model.tar.gz .
tar xfz model.tar.gz
cat class_label_to_prediction_index.json
{"daisy": 0, "dandelion": 1, "roses": 2, "sunflowers": 3, "tulips": 4}

如预期所示，微调后的模型可以预测五个类别。让我们添加一个单元格，从 Wikipedia 下载一张向日葵的图片：
```
%%sh
wget https://upload.wikimedia.org/wikipedia/commons/a/a9/A_sunflower.jpg
```

现在，我们加载这张图片并调用端点：

import boto3
endpoint_name = 'jumpstart-ftd-pt-ic-resnet18'
client = boto3.client('runtime.sagemaker')
with open('A_sunflower.jpg', 'rb') as file:
    image = file.read()
response = client.invoke_endpoint(
    EndpointName=endpoint_name, 
    ContentType='application/x-image',
    Body=image)

最后，我们打印出预测结果。最高的概率是类别 #3，概率为 60.67%，确认我们的图片包含一朵向日葵！

import json
model_predictions = json.loads(response['Body'].read())
print(model_predictions)
[0.30362239480018616, 0.06462913751602173, 0.007234351709485054, 0.6067869663238525, 0.017727158963680267]

测试完成后，请务必删除端点，以避免不必要的费用。

这个例子展示了如何通过 SageMaker JumpStart 在你自己的数据集上微调预训练模型，并用它们预测你自己的数据。这是一个很好的方式，能够尝试不同的模型并找出最适合解决你所面临的特定问题的模型。

这是第一章的结束，已经相当充实了，不是吗？现在是时候回顾我们学到的内容了。

总结

在本章中，你了解了 Amazon SageMaker 的主要功能，以及它们如何帮助解决机器学习中的痛点。通过为你提供托管的基础设施和预安装的工具，SageMaker 使你能够专注于机器学习问题本身。因此，你可以更快地从模型实验过渡到生产部署。

接着，你学习了如何在本地机器和 Amazon SageMaker Studio 中设置 Amazon SageMaker。后者是一个托管的机器学习 IDE，许多其他 SageMaker 功能只需几次点击即可访问。

最后，你了解了 Amazon SageMaker JumpStart，这是一个包含机器学习解决方案和最先进模型的集合，你可以一键部署并在几分钟内开始测试。

在下一章中，我们将看到如何使用 Amazon SageMaker 和其他 AWS 服务来准备你的数据集以进行训练。

第二章：处理数据准备技术

数据是任何机器学习项目的起点，将数据转化为可以用于训练模型的数据集需要大量工作。这项工作通常涉及标注数据集、运行定制的脚本进行预处理，并保存处理后的版本以备后用。如你所料，手动完成所有这些工作，或构建工具来自动化这些过程，对机器学习团队来说并不是一项令人兴奋的任务。

本章将介绍帮助你构建和处理数据的 AWS 服务。我们首先会讲解 Amazon SageMaker Ground Truth，这是 Amazon SageMaker 的一项功能，帮助你快速构建准确的训练数据集。接着，我们会介绍 Amazon SageMaker Data Wrangler，一种交互式转换数据的新方法。然后，我们会讨论 Amazon SageMaker Processing，另一项功能，帮助你运行数据处理工作负载，例如特征工程、数据验证、模型评估和模型解释。最后，我们会简要介绍其他可能有助于数据分析的 AWS 服务：Amazon Elastic Map Reduce、AWS Glue 和 Amazon Athena。

本章包括以下主题：

使用 Amazon SageMaker Ground Truth 标注数据
使用 Amazon SageMaker Data Wrangler 转换数据
使用 Amazon SageMaker Processing 运行批处理作业

技术要求

你需要一个 AWS 账户来运行本章中包含的示例。如果你还没有账户，请访问 aws.amazon.com/getting-started/ 创建一个。你还应该熟悉 AWS 免费套餐，它允许你在特定的使用限制内免费使用许多 AWS 服务。

你需要为你的账户安装并配置 AWS 命令行界面（CLI）（aws.amazon.com/cli/）。

你需要一个正常工作的 Python 3.x 环境。安装 Anaconda 发行版（www.anaconda.com/）不是强制要求，但强烈推荐，因为它包含我们需要的许多项目（Jupyter、pandas、numpy 等）。

本书中的代码示例可以在 GitHub 上找到，地址是 github.com/PacktPublishing/Learn-Amazon-SageMaker-second-edition。你需要安装 Git 客户端才能访问这些示例（git-scm.com/）。

使用 Amazon SageMaker Ground Truth 标注数据

Amazon SageMaker 于 2018 年底增加的 Amazon SageMaker Ground Truth 帮助你快速构建准确的训练数据集。机器学习从业者可以将标注工作分发给公共和私人劳动力的人工标注员。得益于内置工作流程和图形界面，标注员可以立即开始高效工作，处理常见的图像、视频和文本任务。此外，Ground Truth 还支持自动标注技术，这是一种训练机器学习模型使其能够在没有额外人工干预的情况下进行数据标注的技术。

在本节中，你将学习如何使用 Ground Truth 标注图像和文本。

使用劳动力

使用 Ground Truth 的第一步是创建一个劳动力，这是负责标注数据样本的工作组。

让我们进入 SageMaker 控制台：在左侧的垂直菜单中，点击Ground Truth，然后点击标注劳动力。有三种类型的劳动力可供选择：Amazon Mechanical Turk、供应商和私人。我们来讨论一下它们是什么，以及何时使用它们。

Amazon Mechanical Turk

Amazon Mechanical Turk（www.mturk.com/）使得将大型批处理任务拆分为小的工作单元变得更加容易，这些单元可以由分布式劳动力处理。

使用 Mechanical Turk，你可以招募来自全球的成千上万的工人。这是当你需要标注极大数据集时的一个很好的选择。例如，想象一个自动驾驶数据集，由 1,000 小时的视频组成：每一帧都需要处理，以识别其他车辆、行人、交通标志等。如果你想对每一帧进行标注，你将需要处理 1,000 小时 x 3,600 秒 x 每秒 24 帧 = 8640 万张图片！显然，你需要扩展你的标注劳动力才能完成这项工作，而 Mechanical Turk 可以让你做到这一点。

供应商劳动力

尽管 Mechanical Turk 具有良好的可扩展性，但有时你需要更多控制，特别是当数据共享对象和标注质量需要更多关注时，尤其是在需要额外领域知识的情况下。

为此，AWS 已经审核了一些数据标注公司，这些公司已经将 Ground Truth 集成到他们的工作流程中。你可以在AWS Marketplace（aws.amazon.com/marketplace/）中找到这些公司的列表，路径为机器学习 | 数据标注服务 | Amazon SageMaker Ground Truth 服务。

私人劳动力

有时，数据不能由第三方处理。也许它过于敏感，或者可能需要只有你公司员工才拥有的专业知识。在这种情况下，你可以创建一个由明确身份的个人组成的私人劳动力来访问并标注数据。

创建私人劳动力

创建私人劳动力是最快且最简单的选项。让我们来看看如何操作：

从 SageMaker 控制台中的Labeling workforces入口开始，我们选择Private标签，如下图所示。然后，点击Create private team：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_001.jpg

图 2.1 – 创建私有工作团队
我们为团队命名，然后需要决定是通过电子邮件邀请工作人员，还是导入属于现有Amazon Cognito组的用户。

Amazon Cognito (aws.amazon.com/cognito/) 是一种托管服务，可以让您在任何规模下构建和管理用户目录。Cognito 支持社交身份提供者（Google、Facebook 和 Amazon），以及企业身份提供者（Microsoft Active Directory、SAML）。

在企业环境中，这非常有意义，但为了简化流程，我们可以改用电子邮件。在这里，我将使用一些示例电子邮件地址：请确保使用您自己的电子邮件地址，否则您将无法加入团队！
然后，我们需要输入组织名称，更重要的是提供一个工作人员可以用来提问和反馈标注工作的联系方式电子邮件。这些交流非常重要，以便微调标注说明，找出有问题的数据样本等。
可选地，我们可以使用Amazon Simple Notification Service (aws.amazon.com/sns/) 设置通知，以告知工作人员他们有任务需要完成。
屏幕应该像下图所示。然后，我们点击Create private team：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_002.jpg

图 2.2 – 设置私有工作团队
几秒钟后，团队已建立。邀请已发送给工作人员，要求他们通过登录特定的 URL 加入工作团队。邀请邮件如下图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_003.jpg

图 2.3 – 邮件邀请
点击链接会打开一个登录窗口。一旦我们登录并定义了新密码，就会进入一个新页面，显示可用的工作，如下图所示。由于我们尚未定义任何工作，因此它显然是空的：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_004.jpg

图 2.4 – 工作控制台

让我们让工作人员忙起来，创建一个图像标注工作。

上传数据进行标注

正如您所期望的，Amazon SageMaker Ground Truth 使用 Amazon S3 来存储数据集：

使用 AWS CLI，我们创建一个托管在与我们运行 SageMaker 相同区域的 S3 桶。桶名称是全球唯一的，所以请确保在创建桶时选择一个独特的名称。使用以下代码（也可以选择其他 AWS 区域）：
```
$ aws s3 mb s3://sagemaker-book --region eu-west-1
```
然后，我们将位于chapter2文件夹中的猫咪图片从我们的 GitHub 仓库复制过来，如下所示：
```
$ aws s3 cp --recursive cat/ s3://sagemaker-book/chapter2/cat/
```

现在我们有一些等待标注的数据，让我们创建一个标注工作。

创建标签工作

正如你所预期的，我们需要定义数据的位置、标注任务的类型，以及我们的标注指令：

在 SageMaker 控制台的左侧垂直菜单中，我们点击Ground Truth，然后点击标注工作，接着点击创建标注工作按钮。
首先，我们给工作命名，比如’my-cat-job’。然后，我们定义数据在 S3 中的位置。Ground Truth 需要一个清单文件：清单文件是一个JSON 文件，用于过滤哪些对象需要标注，哪些不需要。工作完成后，一个名为增强清单的新文件将包含标注信息，我们将能够使用这个文件来为训练工作提供数据。
然后，我们定义输入数据的位置和类型，正如下面的截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_005.jpg

图 2.5 – 配置输入数据
如下图所示，我们选择了第一章中为 SageMaker 创建的 IAM 角色（你的名字会有所不同），然后点击完成数据设置按钮以验证这一部分：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_006.jpg

图 2.6 – 验证输入数据

点击查看更多详情，你可以了解后台发生了什么。SageMaker Ground Truth 会抓取你在 S3 中的数据，并创建一个名为清单文件的 JSON 文件。如果你感兴趣，可以从 S3 下载它。这个文件指向你在 S3 中的对象（图片、文本文件等）。
可选地，我们可以选择使用完整的清单、随机样本或基于SQL查询的过滤子集。我们还可以提供一个Amazon KMS 密钥来加密作业输出。这里我们保持默认设置。
任务类型部分会询问我们希望执行什么类型的任务。请花一分钟时间浏览可用的不同任务类别（文本、图像、视频、点云和自定义）。如下一张截图所示，让我们选择图像任务类别和语义分割任务，然后点击下一步：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_007.jpg

图 2.7 – 选择任务类型
在下一个屏幕中，如下图所示，我们首先选择我们的私人工作人员团队：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_008.jpg

图 2.8 – 选择团队类型
如果我们有很多样本（比如说，数万个或更多），我们应该考虑启用自动化数据标注，因为此功能能够减少标注任务的持续时间和成本。事实上，当工作者开始标注数据样本时，SageMaker Ground Truth 会使用这些样本训练一个机器学习模型。它会将这些样本用作监督学习问题的数据集。在足够多的工作者标注数据的支持下，这个模型很快就能与人类的准确性匹敌，甚至超过人类的标注准确性，届时它将取代工作者并标注剩余的数据集。如果你想了解更多关于此功能的信息，请阅读文档 docs.aws.amazon.com/sagemaker/latest/dg/sms-automated-labeling.html。
配置训练任务的最后一步是输入工作者的指示。这是一个重要步骤，特别是当你的任务分配给第三方工作者时。我们的指示越清晰，标注的质量就越高。在这里，我们将解释任务的内容，并为工作者输入一个“猫”标签。现实情况下，你应该添加详细的说明，提供良好和不良示例的样本图像，解释你的期望等等。以下截图展示了我们的指示内容：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_010.jpg

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_009.jpg)

图 2.9 – 设置指示
完成指示后，我们点击创建来启动标注任务。几分钟后，任务准备好分配给工作者了。

标注图像

登录到工作者 URL，我们可以从以下截图显示的屏幕看到，我们还有任务要做：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_009.jpg

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_010.jpg)

图 2.10 – 工作者控制台

我们将使用以下步骤：

点击开始工作会打开一个新窗口，接下来图中所示。它显示了说明以及第一个需要处理的图像：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_010.jpg

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_011.jpg)

图 2.11 – 标注图像
使用工具栏中的图形工具，尤其是自动分割工具，我们可以非常快速地制作高质量的标注。请花几分钟时间进行练习，很快你就能做到同样的事情。
一旦我们完成了三个图像的标注，任务就完成了，我们可以在 SageMaker 控制台的标注任务下查看标注的图像。你的屏幕应该像下面的截图一样：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_011.jpg

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_012.jpg)

图 2.12 – 标注图像

更重要的是，我们可以在 S3 输出位置找到标注信息。

特别是，output/my-cat-job/manifests/output/output.manifest 包含每个数据样本的标注信息，例如图像中存在的类别，以及分割掩码的链接。

在第五章**，训练计算机视觉模型中，我们将看到如何将这些信息直接输入到 Amazon SageMaker 中内置的计算机视觉算法。当然，我们也可以解析这些信息，并根据我们用于训练计算机视觉模型的框架进行转换。

如您所见，SageMaker Ground Truth 使得标注图像数据集变得非常简单。您只需要将数据上传到 S3 并创建一个工作团队。Ground Truth 将自动分配任务，并将结果存储在 S3 中。

我们刚刚看到如何标注图像，那么文本任务呢？嗯，它们同样容易设置和运行。让我们通过一个示例来了解。

标注文本

这是一个标注命名实体识别文本的快速示例。数据集由我博客文章中的一些文本片段组成，我们希望标注所有 AWS 服务名称。这些内容可以在我们的 GitHub 仓库中找到。

我们将通过以下步骤开始标注文本：

首先，让我们使用以下代码将文本片段上传到 S3：

$ aws s3 cp --recursive ner/ s3://sagemaker-book/chapter2/ner/

就像在前面的示例中，我们配置了一个文本标注任务，设置了输入数据并选择了一个 IAM 角色，截图如下所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_013.jpg

图 2.13 – 创建文本标注任务
然后，我们选择文本作为类别，选择命名实体识别作为任务。
在下一个屏幕上，截图如下所示，我们只需再次选择我们的私有团队，添加标签并输入指令：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_014.jpg

图 2.14 – 设置指令
一旦任务准备好，我们登录到工作控制台并开始标注。您可以在以下截图中看到一个标注示例：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_015.jpg

图 2.15 – 标注文本
我们很快就完成了任务，并且可以在我们的 S3 存储桶中找到标注信息。对于每个样本，我们可以看到起始偏移量、结束偏移量以及每个标注实体的标签。

Amazon SageMaker Ground Truth 使得大规模标注数据集变得非常简单。它有许多不错的功能，包括任务链和自定义工作流，强烈建议您访问 docs.aws.amazon.com/sagemaker/latest/dg/sms.html 进一步了解。

现在我们知道如何标注数据集了，接下来让我们看看如何使用 Amazon SageMaker Data Wrangler 轻松地交互式转换数据。

使用 Amazon SageMaker Data Wrangler 转换数据

收集和标注数据样本只是准备数据集的第一步。实际上，您很可能需要预处理数据集，以便进行如下操作：

将其转换为您所使用的机器学习算法所期望的输入格式。
对数值特征进行缩放或标准化。
工程更高级的特征，例如，一热编码（One-Hot Encoding）。
清理并标记文本，以用于自然语言处理应用程序

在机器学习项目的早期阶段，通常不容易明确需要哪些数据转换，或者哪些转换最为高效。因此，实践者通常需要尝试不同的组合，采用多种方式转换数据，训练模型，并评估结果。

在本节中，我们将学习Amazon SageMaker Data Wrangler，这是一个集成在 SageMaker Studio 中的图形界面，使得数据转换变得非常简单，并且能够将结果导出到多种 Jupyter 笔记本中。

在 SageMaker Data Wrangler 中加载数据集

首先，我们需要一个数据集。我们将使用由 S. Moro、P. Cortez 和 P. Rita 在《A Data-Driven Approach to Predict the Success of Bank Telemarketing》中发布的直接营销数据集，Decision Support Systems，Elsevier，62:22-31，2014 年 6 月。

该数据集描述了一个二分类问题：客户是否会接受营销优惠，接受或不接受？它包含了超过 41,000 个客户样本，标签存储在y列中。

我们将按照以下步骤开始使用：

使用 AWS 命令行，我们将下载数据集，解压并将其复制到我们所在区域的默认 SageMaker 桶中（它应该已自动创建）。你可以在本地机器或 Jupyter 终端中运行此操作：

$ aws s3 cp s3://sagemaker-sample-data-us-west-2.s3-us-west-2.amazonaws.com/autopilot/direct_marketing/bank-additional.zip .
$ unzip bank-additional.zip
$ aws s3 cp bank-additional/bank-additional-full.csv s3://sagemaker-ap-northeast-2-123456789012/direct-marketing/

在 SageMaker Studio 中，我们通过文件 | 新建 | Data Wrangler 流来创建新的 Data Wrangler 流。以下截图展示了 Data Wrangler 图像正在加载：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_016.jpg

图 2.16 – 加载 Data Wrangler
一旦 Data Wrangler 准备就绪，导入屏幕将打开。我们还可以在左侧窗格中看到 Data Wrangler 图像，如下一个截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_017.jpg

图 2.17 – 打开 Data Wrangler
我们可以从 S3、Athena 或 Redshift 导入数据（点击添加数据源）。在这里，我们点击 S3。
如下截图所示，我们可以轻松定位到我们刚刚上传的数据集。点击它即可：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_018.jpg

图 2.18 – 定位数据集
这将打开数据集的预览，如下一个截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_019.jpg

图 2.19 – 预览数据集
让我们点击导入，这将打开准备视图，如下一个截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_020.jpg

图 2.20 – 预览数据集
点击**+图标，我们可以添加更多的数据源，将它们与我们的数据集连接或拼接。如果 Data Wrangler 错误地检测了数据类型，我们也可以编辑所有列的数据类型。否则，我们可以选择添加分析**，以可视化我们数据集的属性。这将打开分析视图，如下图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_021.jpg

图 2.21 – 可视化数据集
下一张截图显示了一个关于持续时间与年龄的散点图。看起来是不是很简单？你可以通过选择不同的列进行实验，点击预览查看结果，然后点击保存来创建分析并保存以供后续使用。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_022.jpg

图 2.22 – 构建散点图
除了直方图和散点图，我们还可以构建表格摘要、偏差分析和目标泄漏报告。我们来构建后者，查看是否某些列泄漏到预测中，或者根本没有任何帮助。你可以在下图中看到该报告：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_023.jpg

图 2.23 – 构建目标泄漏报告
该报告告诉我们没有列发生泄漏（所有分数都低于 1）。一些列在预测目标时也没有什么用（某些分数为 0.5 或更低）：我们可能需要在数据处理过程中丢弃这些列。

我们还可以尝试快速模型报告，该报告使用在 SageMaker Studio 中实现的随机森林算法训练模型。不幸的是，弹出一个错误消息，抱怨列名不符合要求。确实，一些列名中包含点号，而 Spark 不允许这种格式。没问题，我们可以在数据处理过程中轻松修复这个问题，然后稍后再构建报告。

实际上，让我们继续使用数据处理工具 Data Wrangler 来转换数据。

在 SageMaker Data Wrangler 中转换数据集

Data Wrangler 包含数百种内置转换，我们也可以添加自己的转换。

从下图所示的准备视图开始，我们点击**+**图标以添加转换。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_024.jpg

图 2.24 – 添加转换
这将打开转换列表，如下图所示。花点时间来浏览它们。
我们从删除标记为无用的列开始，这些列包括marital、day of week、month、housing、cons.conf.idx、nr.employed、cons.price.idx。我们点击marital列。你的屏幕应该如下所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_025.jpg

图 2.25 – 删除列
我们可以预览结果并将转换添加到管道中。我们将对其他需要删除的列重复相同的操作。
现在，让我们删除列名中的这些恼人的点号，用下划线替换它们。最简单的做法是使用df。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_026.jpg

图 2.26 – 应用自定义转换
返回到分析视图，点击步骤，我们可以看到已经应用的转换列表，如下图所示。我们也可以通过点击每个转换右侧的图标来删除它。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_027.jpg

图 2.27 – 查看管道
点击 y 标签，如下一个截图所示。该分类模型的 F1 分数为 0.881，最重要的特征是 duration、euribor3m 和 pdays。通过应用更多的转换并再次构建快速模型，我们可以迭代地衡量我们的特征工程步骤的积极影响（或缺乏影响）。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_028.jpg

图 2.28 – 构建快速模型
回到 job 和 education。我们决定对它们进行编码，以帮助算法理解不同的值是问题的不同维度。从 job 开始，我们应用 job 列，然后该列会自动删除。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_029.jpg

图 2.29 – 对某列进行独热编码
job_admin. 列名中包含一个点！我们可以通过 education 列来移除它…并移除列名中的点。我们本可以应用处理数字转换来缩放和标准化数值列，但现在先停在这里。随时可以继续探索和实验！
最后一点：Data Wrangler 工作流存储在 .flow 文件中，可以在 Jupyter 文件视图中查看。这些是 JSON 文件，您可以（并且应该）将其存储在 Git 仓库中，以便以后重用并与其他团队成员共享。

现在我们的管道已准备好，让我们看看如何将其导出为 Python 代码。只需要单击一次，我们就不需要写任何代码。

导出 SageMaker Data Wrangler 管道

Data Wrangler 使导出管道变得容易，提供四种方式：

纯 Python 代码，您可以直接将其包含到您的机器学习项目中。
运行 SageMaker 处理任务的 Jupyter notebook，它将把管道应用于您的数据集并将结果保存到 S3 中。该 notebook 还包括用于训练模型的可选代码。
一个将处理后数据集存储在 SageMaker Feature Store 中的 Jupyter notebook。
一个创建 SageMaker Pipelines 工作流的 Jupyter notebook，包含处理数据集和在其上训练模型的步骤。

好的，我们开始吧：

从导出视图开始，我们点击“步骤”并选择我们想要导出的步骤。在这里，我选择了所有步骤，如下一个截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_030.jpg

图 2.30 – 选择要导出的步骤
然后，我们只需点击导出步骤并选择四个选项中的一个。在这里，我选择了保存到 S3，以便运行 SageMaker 处理任务。
这将打开一个新的 notebook。我们将在下一节讨论 SageMaker Processing，但现在让我们继续运行任务。一旦“任务状态与 S3 输出位置”单元格完成，我们的数据集就可以在 S3 中使用，如下一个截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_031.jpg

图 2.31 – 在 S3 中定位处理后的数据集
下载并打开存储在此位置的 CSV 文件，我们看到它包含了处理过的数据集，如下一张截图所示。在典型的机器学习工作流中，我们随后将直接使用这些数据来训练模型。

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_032.jpg

Figure 2.32 – Viewing the processed dataset

正如您所见，SageMaker 数据处理非常简单（甚至有趣），可以轻松应用转换到您的数据集。完成后，您可以立即将它们导出为 Python 代码，无需编写任何代码。

在接下来的部分中，我们将学习关于 Amazon SageMaker 处理（Processing）的内容，这是一个执行批处理数据处理和其他机器学习任务的绝佳方式。

使用 Amazon SageMaker 处理运行批处理作业

如前节所述，数据集通常需要大量工作才能准备好进行训练。一旦训练完成，您可能还希望运行额外的作业来后处理预测数据并评估您的模型在不同数据集上的表现。

一旦实验阶段完成，最好开始自动化所有这些作业，这样您就可以随需求轻松运行它们。

探索 Amazon SageMaker 处理 API

Amazon SageMaker 处理 API 是 SageMaker SDK 的一部分，我们在Chapter 1**，Introducing Amazon SageMaker中安装了该 SDK。

SageMaker 处理作业运行在 Docker 容器内部：

一个内置的scikit-learn容器（scikit-learn.org）
一个内置的PySpark容器（spark.apache.org/docs/latest/api/python/），支持分布式训练
您自己的自定义容器

日志可在/aws/sagemaker/ProcessingJobs日志组中找到。

让我们首先看看如何使用 scikit-learn 和 SageMaker 处理准备数据集进行训练。

使用 scikit-learn 处理数据集

这里是高级流程：

将您的未加工数据集上传到 Amazon S3。
使用 scikit-learn 编写脚本以加载数据集，处理它，并保存处理过的特征和标签。
使用 SageMaker 处理在托管基础设施上运行此脚本。

将数据集上传到 Amazon S3

我们将重用前一节介绍的直接营销数据集，并应用我们自己的转换。

创建一个新的 Jupyter 笔记本，让我们首先下载并提取数据集：

%%sh
apt-get -y install unzip
wget -N https://sagemaker-sample-data-us-west-2.s3-us-west-2.amazonaws.com/autopilot/direct_marketing/bank-additional.zip
unzip -o bank-additional.zip

然后，我们用pandas加载它：

import pandas as pd
data = pd.read_csv('./bank-additional/bank-additional-full.csv')
print(data.shape)
(41188, 21)

现在，让我们显示前五行：
```
data[:5] 
```
This prints out the table visible in the following figure:

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_033.jpg

Figure 2.33 – Viewing the dataset

向右滚动，我们可以看到一个名为y的列，存储了标签。
现在，让我们将数据集上传到 Amazon S3. 我们将使用 SageMaker 在我们运行的区域自动创建的默认存储桶。我们只需添加前缀以保持事务井然有序：
```
import sagemaker
prefix = 'sagemaker/DEMO-smprocessing/input'
input_data = sagemaker.Session().upload_data(path='./bank-additional/bank-additional-full.csv', key_prefix=prefix)
```

使用 scikit-learn 编写处理脚本

由于 SageMaker Processing 负责所有基础设施工作，我们可以专注于脚本本身。SageMaker Processing 还会自动将输入数据集从 S3 复制到容器内，并将处理后的数据集从容器复制到 S3：

配置作业时，我们会提供容器路径。以下是我们将使用的路径：

输入数据集：/opt/ml/processing/input
处理后的训练集：/opt/ml/processing/train
处理后的测试集：/opt/ml/processing/test

在我们的 Jupyter 环境中，让我们开始编写一个新的 Python 文件，名为preprocessing.py。正如你所期待的，这个脚本将加载数据集，执行基本的特征工程，并保存处理后的数据集：

首先，我们使用argparse库（docs.python.org/3/library/argparse.html）读取我们的单个命令行参数：训练集和测试集的比例。实际值将通过 SageMaker Processing SDK 传递给脚本：

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--train-test-split-ratio', 
                    type=float, default=0.3)
args, _ = parser.parse_known_args()
print('Received arguments {}'.format(args))
split_ratio = args.train_test_split_ratio

我们使用pandas加载输入数据集。在启动时，SageMaker Processing 会自动将其从 S3 复制到容器内的用户定义位置/opt/ml/processing/input：
```
import os
import pandas as pd
input_data_path = os.path.join('/opt/ml/processing/input', 'bank-additional-full.csv')
df = pd.read_csv(input_data_path) 
```
然后，我们删除任何缺失值的行，以及重复的行：
```
df.dropna(inplace=True)
df.drop_duplicates(inplace=True)
```

然后，我们统计负样本和正样本，并显示类别比例。这将告诉我们数据集的不平衡程度：

one_class = df[df['y']=='yes']
one_class_count = one_class.shape[0]
zero_class = df[df['y']=='no']
zero_class_count = zero_class.shape[0]
zero_to_one_ratio = zero_class_count/one_class_count
print("Ratio: %.2f" % zero_to_one_ratio)

查看数据集，我们可以看到有一列名为pdays，表示客户最后一次联系的时间。有些行的值为 999，这看起来相当可疑：实际上，这个值是一个占位符，表示该客户从未被联系过。为了帮助模型理解这一假设，我们将添加一个新列，明确指出这一点：
```
import numpy as np
df['no_previous_contact'] = 
   np.where(df['pdays'] == 999, 1, 0)
```
在职位列中，我们可以看到三种类别（student、retired 和 unemployed），它们可能应该合并在一起，表示这些客户没有全职工作。我们来添加另一列：
```
df['not_working'] = np.where(np.in1d(df['job'], ['student', 'retired', 'unemployed']), 1, 0)
```

现在，让我们将数据集拆分为训练集和测试集。Scikit-learn 提供了一个方便的 API，我们根据传递给脚本的命令行参数来设置拆分比例：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
        df.drop('y', axis=1),
        df['y'],
        test_size=split_ratio, random_state=0)

下一步是对数值特征进行缩放，并对分类特征进行独热编码。我们将使用StandardScaler来处理数值特征，使用OneHotEncoder来处理分类特征：

from sklearn.compose import make_column_transformer
from sklearn.preprocessing import StandardScaler,OneHotEncoder
preprocess = make_column_transformer(
  (StandardScaler(), ['age', 'duration', 'campaign', 'pdays', 'previous']),
  (OneHotEncoder(sparse=False), ['job', 'marital', 'education', 'default', 'housing', 'loan','contact', 'month', 'day_of_week', 'poutcome'])
)

然后，我们处理训练集和测试集：

train_features = preprocess.fit_transform(X_train)
test_features = preprocess.transform(X_test)

最后，我们保存处理后的数据集，将特征和标签分开。它们被保存到容器内用户定义的位置，SageMaker Processing 会在作业结束前自动将文件复制到 S3：

train_features_output_path = os.path.join('/opt/ml/processing/train', 'train_features.csv')
train_labels_output_path = os.path.join('/opt/ml/processing/train', 'train_labels.csv')
test_features_output_path = os.path.join('/opt/ml/processing/test', 'test_features.csv')
test_labels_output_path = os.path.join('/opt/ml/processing/test', 'test_labels.csv')
pd.DataFrame(train_features).to_csv(train_features_output_path, header=False, index=False)
pd.DataFrame(test_features).to_csv(test_features_output_path, header=False, index=False)
y_train.to_csv(train_labels_output_path, header=False, index=False)
y_test.to_csv(test_labels_output_path, header=False, index=False)

就这样。如你所见，这段代码是标准的 scikit-learn，因此将自己的脚本适配到 SageMaker Processing 并不困难。现在，让我们看看如何实际运行这个过程。

运行处理脚本

回到我们的 Jupyter 笔记本，我们使用 SageMaker SDK 中的SKLearnProcessor对象来配置处理作业：

首先，我们定义要使用的 scikit-learn 版本和我们的基础设施需求。在这里，我们选择一个 ml.m5.xlarge 实例，这是一个多功能的良好选择：

from sagemaker.sklearn.processing import SKLearnProcessor
sklearn_processor = SKLearnProcessor(
    framework_version='0.23-1',
    role=sagemaker.get_execution_role(),
    instance_type='ml.m5.xlarge',
    instance_count=1)

然后，我们只需启动作业，传递脚本的名称、S3 中数据集的输入路径、SageMaker Processing 环境中用户定义的数据集路径以及命令行参数：

from sagemaker.processing import ProcessingInput, ProcessingOutput
sklearn_processor.run(
    code='preprocessing.py',
    inputs=[ProcessingInput(
        source=input_data,   # Our data in S3                   
        destination='/opt/ml/processing/input')
    ],               
    outputs=[
        ProcessingOutput(
            source='/opt/ml/processing/train',                             
            output_name='train_data'),                                   
        ProcessingOutput(
            source='/opt/ml/processing/test',
            output_name='test_data'                                                 
            )
    ],
    arguments=['--train-test-split-ratio', '0.2']
)

当作业开始时，SageMaker 会自动配置一个托管的 ml.m5.xlarge 实例，将适当的容器拉取到该实例，并在容器内运行我们的脚本。一旦作业完成，实例会被终止，我们只需为实际使用的时间付费。完全无需管理基础设施，也不会因为没有理由而让空闲实例长时间运行。

几分钟后，作业完成，我们可以看到脚本的输出如下：

Received arguments Namespace(train_test_split_ratio=0.2)
Reading input data from /opt/ml/processing/input/bank-additional-full.csv
Positive samples: 4639
Negative samples: 36537
Ratio: 7.88
Splitting data into train and test sets with ratio 0.2
Running preprocessing and feature engineering transformations
Train data shape after preprocessing: (32940, 58)
Test data shape after preprocessing: (8236, 58)
Saving training features to /opt/ml/processing/train/train_features.csv
Saving test features to /opt/ml/processing/test/test_features.csv
Saving training labels to /opt/ml/processing/train/train_labels.csv
Saving test labels to /opt/ml/processing/test/test_labels.csv

以下截图显示了 CloudWatch 中的相同日志：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_02_034.jpg

图 2.34 – 在 CloudWatch Logs 中查看日志

最后，我们可以描述作业并查看处理后的数据集位置：

preprocessing_job_description = 
   sklearn_processor.jobs[-1].describe()
output_config = preprocessing_job_description['ProcessingOutputConfig']
for output in output_config['Outputs']:
    print(output['S3Output']['S3Uri'])

这将产生以下输出：

s3://sagemaker-eu-west-1-123456789012/sagemaker-scikit-learn-2020-04-22-10-09-43-146/output/train_data
s3://sagemaker-eu-west-1-123456789012/sagemaker-scikit-learn-2020-04-22-10-09-43-146/output/test_data

在终端中，我们可以使用 AWS CLI 获取位于前述路径的处理过的训练集，并查看第一个样本和标签：

$ aws s3 cp s3://sagemaker-eu-west-1-123456789012/sagemaker-scikit-learn-2020-04-22-09-45-05-711/output/train_data/train_features.csv .
$ aws s3 cp s3://sagemaker-eu-west-1-123456789012/sagemaker-scikit-learn-2020-04-22-09-45-05-711/output/train_data/train_labels.csv .
$ head -1 train_features.csv
0.09604515376959515,-0.6572847857673993,-0.20595554104907898,0.19603112301129622,-0.35090125695736246,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0
$ head -1 train_labels.csv
no

现在数据集已经用我们的代码处理完成，我们可以用它来训练一个机器学习模型。在实际应用中，我们还会自动化这些步骤，而不是手动在笔记本中运行。

重要提示

最后一个要点：在这里，我们的作业将输出数据写入 S3。SageMaker Processing 还支持直接写入现有的 SageMaker Feature Store 中的 Feature Group（我们将在本书后面介绍）。API 详细信息可以在 sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.processing.ProcessingOutput 中查看。

使用你自己的代码处理数据集

在前面的示例中，我们使用了一个内置容器来运行我们的 scikit-learn 代码。SageMaker Processing 还支持使用自定义容器。你可以在 docs.aws.amazon.com/sagemaker/latest/dg/build-your-own-processing-container.html 找到一个示例。

如你所见，SageMaker Processing 使得运行数据处理作业变得非常简单。你可以专注于编写和运行脚本，而无需担心基础设施的配置和管理。

总结

在本章中，你学习了 Amazon SageMaker Ground Truth 如何帮助你通过图像和文本标注工作流构建高度准确的训练数据集。我们将在 第五章 中看到如何使用通过 Ground Truth 标注的图像数据集来训练计算机视觉模型。

然后，你了解了 Amazon SageMaker 处理功能，这是一个帮助你在托管基础设施上运行自定义数据处理工作负载的能力：特征工程、数据验证、模型评估等等。

最后，我们讨论了另外三个 AWS 服务（Amazon EMR、AWS Glue 和 Amazon Athena），以及它们如何融入到你的分析和机器学习工作流中。

在下一章，我们将开始使用 Amazon SageMaker 内置的机器学习模型来训练模型。

第二部分：构建和训练模型

在本节中，你将了解如何使用 Amazon SageMaker 构建和训练机器学习模型。本部分涵盖了 AutoML、内置算法、内置框架以及自定义代码。通过基于 SageMaker SDK 的笔记本，它将解释如何读取训练数据、如何设置训练任务、如何定义训练参数，以及如何在完全托管的基础设施上进行训练。

本节包括以下章节：

第三章，使用 Amazon SageMaker AutoPilot 进行 AutoML
第四章，训练机器学习模型
第五章，训练计算机视觉模型
第六章，训练自然语言处理模型
第七章，使用内置框架扩展机器学习服务
第八章，使用你的算法和代码

第三章：使用亚马逊 SageMaker Autopilot 进行 AutoML

在上一章中，您已经了解了亚马逊 SageMaker 如何帮助您构建和准备数据集。在典型的机器学习项目中，下一步将是开始尝试不同的算法，以找到初步适合的模型，并了解您可以从模型中预期的预测能力。

无论你是使用传统机器学习还是深度学习，在选择算法时有三个选项：

写自己的代码，或者自定义现有代码。只有在你具备强大的统计和计算机科学技能，并且相当确定你能比调优后的现成算法做得更好，而且有足够的时间来完成项目时，这才有意义。让我们面对现实吧，这些条件很少能够满足。
使用内置算法实现您喜欢的库中的一个，如线性回归或XGBoost。对于深度学习问题，这包括在TensorFlow、PyTorch等中可用的预训练模型。此选项省去了编写机器学习代码的麻烦，而是让您专注于特征工程和模型优化。
使用AutoML，这是一种新兴技术，可以自动构建、训练和优化机器学习模型。

在本章中，您将了解亚马逊 SageMaker Autopilot，这是亚马逊 SageMaker 的 AutoML 功能之一，具有内置的模型可解释性。我们将看到如何在亚马逊 SageMaker Studio 中使用它，而无需编写一行代码，并且如何使用亚马逊 SageMaker SDK：

发现亚马逊 SageMaker Autopilot
在 SageMaker Studio 中使用亚马逊 SageMaker Autopilot
使用亚马逊 SageMaker Autopilot 和 SageMaker SDK
深入探讨亚马逊 SageMaker Autopilot

技术要求

您需要一个 AWS 帐户来运行本章中包含的示例。如果您尚未拥有，请访问aws.amazon.com/getting-started/创建一个。您还应该熟悉 AWS Free Tier（aws.amazon.com/free/），它允许您在一定使用限制内免费使用许多 AWS 服务。

您将需要为您的帐户安装和配置 AWS 命令行界面（CLI）（aws.amazon.com/cli/）。

您将需要一个运行 Python 3.x 的环境。虽然安装 Anaconda 发行版（www.anaconda.com/）不是强制的，但强烈建议这样做，因为它包含了我们需要的许多项目（Jupyter、pandas、numpy等）。

本书中包含的代码示例可在 GitHub 上访问（github.com/PacktPublishing/Learn-Amazon-SageMaker-second-edition）。您需要安装 Git 客户端才能访问这些示例（git-scm.com/）。

发现 Amazon SageMaker Autopilot

Amazon SageMaker Autopilot 于 2019 年末加入 Amazon SageMaker，是一个 AutoML 功能，能够为你处理所有机器学习步骤。你只需要将列数据集上传到 Amazon S3 存储桶，并定义你希望模型学习的列（目标属性）。然后，你只需启动一个 Autopilot 作业，无论是通过在 SageMaker Studio GUI 中点击几下，还是使用 SageMaker SDK 编写几行代码。

SageMaker Autopilot 的简便性并不意味着缺乏透明度和控制权。你可以看到模型是如何构建的，并且可以不断实验以优化结果。从这个角度来看，SageMaker Autopilot 应该能吸引新手和经验丰富的从业者。

在这一部分中，你将了解 SageMaker Autopilot 作业的不同步骤，以及它们如何帮助提供高质量的模型：

数据分析
特征工程
模型调优

让我们从了解 SageMaker Autopilot 如何分析数据开始。

数据分析

这一步骤负责理解我们要解决的机器学习问题类型。SageMaker Autopilot 当前支持 线性回归、二元分类 和 多类别分类。

注意

一个常见的问题是：“构建这样的模型需要多少数据？”这是一个出人意料的难题。答案—如果有的话—取决于许多因素，比如特征的数量和质量。作为一个基本的经验法则，一些从业者建议样本数量是特征数量的 10 到 100 倍。无论如何，我建议你至少收集几百个样本（如果你在构建分类模型的话，应该按类别收集样本）。如果有更多特征，收集上千或上万个样本会更好。对于统计机器学习来说，通常不需要几百万个样本，因此从现有数据开始，分析结果，进行迭代，再决定是否需要收集更多数据！

通过分析目标属性的分布，SageMaker Autopilot 可以轻松判断哪一种是正确的。例如，如果目标属性只有两个值（比如“是”和“否”），那么你很可能是在构建一个二元分类模型。

然后，SageMaker Autopilot 会计算数据集和各个列的统计信息：唯一值的数量、均值、中位数等等。机器学习从业者通常会这样做，以便初步了解数据，看到这一过程自动化也是很好的。此外，SageMaker Autopilot 还会生成一个 Jupyter 笔记本，数据探索笔记本，以用户友好的方式呈现这些统计信息。

一旦 SageMaker Autopilot 分析了数据集，它会构建 候选管道，用于训练候选模型。管道是以下内容的组合：

一个数据处理任务，负责特征工程。正如你所猜测的，这个任务运行在Amazon SageMaker Processing上，正如我们在第二章《数据准备技巧》中所研究的那样。
一个训练任务，运行在处理过的数据集上。算法包括 SageMaker 中内置的 Linear Learner、XGBoost 和多层感知机。

接下来，让我们看看 Autopilot 如何在特征工程中发挥作用。

特征工程

这一步负责根据数据分析过程中定义的管道来预处理输入数据集。

候选管道在另一个自动生成的笔记本中进行了完整文档记录——候选生成笔记本。这个笔记本不仅仅是描述性的：你实际上可以运行它的单元格，手动重现 SageMaker Autopilot 执行的步骤。这种透明度和控制级别非常重要，因为它可以让你准确理解模型是如何构建的。因此，你可以验证它是否按预期执行，并且能够向你的利益相关者解释它。此外，如果你有兴趣，你还可以使用这个笔记本作为进一步优化和调整的起点。

最后，让我们看看 Autopilot 中的模型调优。

模型调优

这一步负责根据数据分析过程中定义的管道来训练和调优模型。对于每个管道，SageMaker Autopilot 将启动一个自动模型调优任务（我们将在后续章节中详细介绍这个主题）。简而言之，每个调优任务将使用超参数优化在处理过的数据集上训练大量逐渐提高精度的模型。像往常一样，所有这些都发生在受管的基础设施上。

一旦模型调优完成，您可以在 Amazon SageMaker Studio 中查看模型信息和指标，构建可视化图表等。您也可以使用Amazon SageMaker Experiments SDK 以编程方式执行相同的操作。

最后，您可以像使用任何其他 SageMaker 模型一样部署所选模型，使用 SageMaker Studio GUI 或 SageMaker SDK。

现在我们理解了 Autopilot 任务的不同步骤，让我们在 SageMaker Studio 中运行一个任务。

在 SageMaker Studio 中使用 Amazon SageMaker Autopilot

我们将仅使用 SageMaker Studio 构建一个模型。我们不会写一行机器学习代码，所以准备好进行零代码 AI。

在本节中，您将学习如何完成以下操作：

在 SageMaker Studio 中启动一个 SageMaker Autopilot 任务。
监控任务的不同步骤。
可视化模型并比较它们的属性。

启动任务

首先，我们需要一个数据集。我们将重新使用在第二章《数据准备技巧》中使用的直接营销数据集。这个数据集描述了一个二分类问题：客户是否会接受营销优惠，是或不是？它包含了超过 41,000 个标记的客户样本。让我们深入了解：

让我们打开 SageMaker Studio。使用数据科学内核创建一个新的 Python 3 笔记本，如下图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_001.jpg

图 3.1 – 创建一个笔记本

现在，让我们按以下步骤下载并提取数据集：

%%sh
apt-get -y install unzip
wget -N https://sagemaker-sample-data-us-west-2.s3-us-west-2.amazonaws.com/autopilot/direct_marketing/bank-additional.zip
unzip -o bank-additional.zip

在第二章《数据处理技巧》中，我们通过 Amazon SageMaker Processing 运行了一个特征工程脚本。但在这里，我们不做这样的操作：我们只是将数据集原封不动地上传到 S3，上传到 SageMaker 创建的默认桶中：
```
import sagemaker
prefix = 'sagemaker/DEMO-autopilot/input'
sess   = sagemaker.Session()
uri = sess.upload_data(path=”./bank-additional/bank-additional-full.csv”, key_prefix=prefix)
print(uri)
```
数据集将可在 S3 中的以下位置获取：
```
s3://sagemaker-us-east-2-123456789012/sagemaker/DEMO-autopilot/input/bank-additional-full.csv
```
现在，我们点击左侧垂直图标栏中的组件与注册表图标，正如下图所示。这将打开实验标签页，我们点击创建自动驾驶实验按钮以创建一个新的自动驾驶任务。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_002.jpg

图 3.2 – 查看实验
下一个屏幕是我们配置任务的地方。让我们输入my-first-autopilot-job作为实验名称。
我们使用第 3 步返回的路径设置输入数据集的位置。如下图所示，我们可以浏览 S3 桶，或者直接输入 S3 位置：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_003.jpg

图 3.3 – 定义输入位置
下一步是定义目标属性的名称，如下图所示。存储“是”或“否”标签的列称为“y”。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_004.jpg

图 3.4 – 定义目标属性
如下图所示，我们设置任务输出文件的位置，任务生成的工件将被复制到该位置。我在此使用 s3://sagemaker-us-east-2-123456789012/sagemaker/DEMO-autopilot/output/，当然，你应该用你自己的区域和账户编号来更新此位置。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_005.jpg

图 3.5 – 定义输出位置
我们设置所需的任务类型，如下图所示。在这里，我们选择自动，让 SageMaker Autopilot 自动确定问题类型。或者，我们可以选择二元分类，并选择我们的指标：准确率、AUC 或 F1（默认设置）。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_006.jpg

图 3.6 – 设置问题类型
最后，我们决定是运行完整任务，还是仅生成笔记本。如果选择前者，则如下一图所示。如果选择后者，那么当我们希望手动训练并调整参数时，它将是一个不错的选择。我们还决定暂时不自动部署最佳模型。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_007.jpg

图 3.7 – 运行完整实验
可选地，在高级设置部分，我们可以更改 IAM 角色，设置作业工件的加密密钥，定义我们希望启动作业实例的 VPC 等。这里我们保持默认值。
任务设置已完成：这一切只需要一个屏幕。然后，我们点击创建实验，任务就开始了！

监控任务

一旦任务启动，它将经过我们已经讨论过的三个步骤，预计大约需要 5 小时完成。新实验会列在实验标签中，我们可以右键点击描述 AutoML 任务以查看其当前状态。这会打开如下屏幕，我们可以看到任务的进度：

如预期的那样，任务开始时会分析数据，如下面的截图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_008.jpg

图 3.8 – 查看任务进度
大约 10 分钟后，数据分析完成，任务进入特征工程阶段，此时输入数据集将按照候选管道中定义的步骤进行转换。如下面的截图所示，我们还可以看到右上角新增了两个按钮，分别指向候选生成和数据探索笔记本：别担心，我们将在本章后面详细讲解这两者。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_009.jpg

图 3.9 – 查看任务进度
一旦特征工程完成，接下来的工作就是模型调优，在这一阶段，候选模型会被训练和调整。如下面的截图所示，第一个训练任务很快出现在试验标签中。 "试验"是 SageMaker 用来表示一组相关任务的名称，例如处理任务、批量转换任务和训练任务。我们可以看到目标，也就是任务试图优化的指标（在本例中是 F1 得分）。我们可以根据该指标对任务进行排序，当前最好的调优任务会被高亮显示并标注星标。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_010.jpg

图 3.10 – 查看调优任务
一旦 AutoPilot 任务完成，你的屏幕应该会类似于以下截图。在这里，顶部模型达到了 0.8031 的 F1 得分。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_011.jpg

图 3.11 – 查看结果
如果我们选择最佳任务并右键点击打开模型详细信息，我们可以看到一个模型可解释性图，显示了最重要的特征，如下截图所示。该图基于由 AutoPilot 自动计算的全局SHapley 加法解释（SHAP）值 (github.com/slundberg/shap)。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_012.jpg

图 3.12 – 查看最重要特征
在 Artifacts（工件）标签中，我们还可以看到构建模型时涉及的训练工件和参数的列表：输入数据、训练和验证分割、转换后的数据集、特征工程代码、算法（在我的案例中是 XGBoost）等。

此时，我们可以直接部署最佳作业，但我们将使用 SageMaker Studio 内置的可视化工具来比较前 10 个作业。

比较作业

默认情况下，单个 SageMaker Autopilot 作业会训练 250 个作业。随着时间的推移，你可能会有成千上万个作业，并且你可能希望比较它们的属性。让我们看看如何操作：

在左侧的 Experiments 标签页中，我们定位到我们的作业，右键点击在试验组件列表中打开，如下图所示：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_013.jpg

图 3.13 – 打开试验列表
这将打开试验组件列表，如下图所示。

我们点击右侧的齿轮图标打开 表格属性 面板，然后取消勾选除 Experiment name（实验名称）、Trial component name（试验组件名称）和 ObjectiveMetric（目标指标）以外的所有选项。在主面板中，我们通过点击箭头将作业按目标指标降序排序。按住Shift键并点击前 10 个作业进行选择，如下图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_014.jpg

图 3.14 – 比较作业
然后，我们点击添加图表按钮。这将打开一个新的视图，见下图所示。点击图表框底部以打开右侧的图表属性面板。https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_015.jpg

图 3.15 – 创建图表

由于我们的训练作业非常短（大约一分钟），因此没有足够的数据生成时间序列图表，所以我们选择汇总统计。我们将构建一个散点图，将 eta 和 lambda 超参数进行对比，如下图所示。我们还将数据点按我们的试验名称进行着色。

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_016.jpg

图 3.16 – 创建图表
放大下图，我们可以快速地可视化我们的作业及其相应的参数。我们还可以构建其他图表，展示某些超参数对准确率的影响。这将帮助我们筛选出一些模型进行进一步的测试。也许我们最终会考虑将多个模型用于集成预测。

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_017.jpg

图 3.17 – 绘制超参数图

下一步是部署模型并开始测试。

部署和调用模型

SageMaker Studio 使得部署模型变得非常简单。让我们看看如何操作：

返回到实验标签页，我们右键点击实验名称并选择描述 AutoML 作业。这会打开训练作业列表。确保它们按目标值降序排列，我们选择最好的那个（它会用星标高亮显示），如下图所示，然后点击部署模型按钮：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_018.jpg

图 3.18 – 部署模型
在my-first-autopilot-endpoint下，保持其他设置不变，点击ml.m5.xlarge实例：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_019.jpg

图 3.19 – 部署模型
进入左侧垂直面板中的端点部分，我们可以看到正在创建的端点。如下面的截图所示，最初它会处于创建中状态。几分钟后，它会变为在服务中：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_020.jpg

图 3.20 – 创建端点
转到 Jupyter 笔记本（我们可以重复使用写来下载数据集的那个），我们定义端点的名称和要预测的样本。这里，我使用的是数据集的第一行：
```
ep_name = 'my-first-autopilot-endpoint'
sample = '56,housemaid,married,basic.4y,no,no,no,telephone,may,mon,261,1,999,0,nonexistent,1.1,93.994,-36.4,4.857,5191.0'
```
我们为 SageMaker 运行时创建一个boto3客户端。这个运行时包含一个 API，invoke_endpoint (boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html)。这使得它非常高效，适合嵌入到只需要调用模型的客户端应用程序中：
```
import boto3
sm_rt = boto3.Session().client('runtime.sagemaker')
```

我们将样本发送到端点，同时传递输入和输出内容类型：

response = sm_rt.invoke_endpoint(EndpointName=ep_name,
                              ContentType='text/csv',
                              Accept='text/csv',
                              Body=sample)

我们解码预测结果并打印出来——该客户不太可能接受该提议：
```
response = response['Body'].read().decode(”utf-8”)
print(response)
```
这个样本被预测为“否”：
```
no
```
当我们完成测试端点时，我们应该删除它以避免不必要的费用。我们可以通过boto3中的delete_endpoint API 来实现这一点(boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.delete_endpoint)：
```
sm = boto3.Session().client('sagemaker')
sm.delete_endpoint(EndpointName=ep_name)
```

恭喜！你已经成功地在 Amazon SageMaker 上构建、训练并部署了你的第一个机器学习模型。是不是很简单？我们写的唯一代码是下载数据集并用模型进行预测。

使用SageMaker Studio是快速尝试新数据集的好方法，也让技术要求较低的用户可以独立构建模型。高级用户还可以将自己的自定义镜像添加到 SageMaker Studio，更多详细信息请参考docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html。

现在，让我们看看如何通过SageMaker SDK以编程方式使用 SageMaker Autopilot。

使用 SageMaker Autopilot SDK

Amazon SageMaker SDK 包括一个简单的 API 用于 SageMaker Autopilot。你可以在 sagemaker.readthedocs.io/en/stable/automl.html 查阅文档。

在本节中，你将学习如何使用此 API 在与上一节相同的数据集上训练模型。

启动任务

SageMaker SDK 使启动 Autopilot 任务变得异常简单——只需将数据上传到 S3，然后调用一个 API！让我们来看看如何操作：

首先，我们导入 SageMaker SDK：

import sagemaker
sess = sagemaker.Session()

接着，我们下载数据集：

%%sh
wget -N https://sagemaker-sample-data-us-west-2.s3-us-west-2.amazonaws.com/autopilot/direct_marketing/bank-additional.zip
unzip -o bank-additional.zip

接下来，我们将数据集上传到 S3：

bucket = sess.default_bucket()                     
prefix = 'sagemaker/DEMO-automl-dm'
s3_input_data = sess.upload_data(path=”./bank-additional/bank-additional-full.csv”, key_prefix=prefix+'input')

接着，我们配置 AutoML 任务，这只需要一行代码。我们定义了目标属性（记住，这一列的名称是“y”），以及训练产物的存储位置。可选地，我们还可以设置任务的最大运行时间、每个任务的最大运行时间，或者减少将要调优的候选模型数量。请注意，限制任务持续时间过多可能会影响其准确性。对于开发目的而言，这不是问题，因此我们将任务时长限制为一小时，或者 250 个调优任务（以先到为准）：

from sagemaker.automl.automl import AutoML
auto_ml_job = AutoML(
    role = sagemaker.get_execution_role(),                                          
    sagemaker_session = sess,                             
    target_attribute_name = 'y',                             
    output_path = 
        's3://{}/{}/output'.format(bucket,prefix),
    max_runtime_per_training_job_in_seconds = 600,
    max_candidates = 250,
    total_job_runtime_in_seconds = 3600
)

接下来，我们启动 Autopilot 任务，传递给它训练集的位置。我们关闭日志（谁想阅读数百个调优日志呢？），并将调用设置为非阻塞，因为我们希望在接下来的单元格中查询任务状态：
```
auto_ml_job.fit(inputs=s3_input_data, logs=False, wait=False)
```

任务会立刻开始。现在让我们看看如何监控它的状态。

监控任务

在任务运行时，我们可以使用describe_auto_ml_job() API 来监控其进度：

例如，以下代码将每 60 秒检查一次任务的状态，直到数据分析步骤完成：

from time import sleep
job = auto_ml_job.describe_auto_ml_job()
job_status = job['AutoMLJobStatus']
job_sec_status = job['AutoMLJobSecondaryStatus']
if job_status not in ('Stopped', 'Failed'):
    while job_status in ('InProgress') and job_sec_status in ('AnalyzingData'):
        sleep(60)
        job = auto_ml_job.describe_auto_ml_job()
        job_status = job['AutoMLJobStatus']
        job_sec_status =   
             job['AutoMLJobSecondaryStatus']
        print (job_status, job_sec_status)

一旦数据分析完成，两个自动生成的 notebook 就会可用。我们可以使用相同的 API 查找它们的位置：

job = auto_ml_job.describe_auto_ml_job()
job_candidate_notebook = job['AutoMLJobArtifacts']['CandidateDefinitionNotebookLocation']
job_data_notebook = job['AutoMLJobArtifacts']['DataExplorationNotebookLocation']
print(job_candidate_notebook)
print(job_data_notebook)

这会打印出两个 notebook 的 S3 路径：

s3://sagemaker-us-east-2-123456789012/sagemaker/DEMO-automl-dm/output/automl-2020-04-24-14-21-16-938/sagemaker-automl-candidates/pr-1-a99cb56acb5945d695c0e74afe8ffe3ddaebafa94f394655ac973432d1/notebooks/SageMakerAutopilotCandidateDefinitionNotebook.ipynb
s3://sagemaker-us-east-2-123456789012/sagemaker/DEMO-automl-dm/output/automl-2020-04-24-14-21-16-938/sagemaker-automl-candidates/pr-1-a99cb56acb5945d695c0e74afe8ffe3ddaebafa94f394655ac973432d1/notebooks/SageMakerAutopilotDataExplorationNotebook.ipynb

使用 AWS CLI，我们可以将两个 notebook 下载到本地。我们稍后将在本章中查看它们：
```
%%sh -s $job_candidate_notebook $job_data_notebook
aws s3 cp $1 .
aws s3 cp $2 .
```
当特征工程运行时，我们可以使用与之前相同的代码片段等待完成，循环判断 job_sec_status 是否等于 FeatureEngineering。

一旦模型调优完成，我们可以非常轻松地找到最佳候选模型：

job_best_candidate = auto_ml_job.best_candidate()
print(job_best_candidate['CandidateName'])
print(job_best_candidate['FinalAutoMLJobObjectiveMetric'])

这会输出最佳调优任务的名称及其验证准确度：

tuning-job-1-57d7f377bfe54b40b1-030-c4f27053
{'MetricName': 'validation:accuracy', 'Value': 0.9197599935531616}

然后，我们可以使用 SageMaker SDK 部署并测试模型。我们已经涵盖了很多内容，所以将这部分留到后续章节，我们会重新回顾这个例子。

清理

SageMaker Autopilot 创建了许多底层产物，例如数据集拆分、预处理脚本、预处理数据集和模型。如果你想完全清理，下面的代码片段可以做到这一点。当然，你也可以使用 AWS CLI：

import boto3
job_outputs_prefix = '{}/output/{}'.format(prefix, job['AutoMLJobName'])
s3_bucket = boto3.resource('s3').Bucket(bucket)
s3_bucket.objects.filter(Prefix=job_outputs_prefix).delete()

既然我们已经知道如何使用 SageMaker Studio GUI 和 SageMaker SDK 训练模型，让我们深入了解其背后的原理。工程师们喜欢理解事物是如何真正工作的，对吧？

深入了解 SageMaker Autopilot

在本节中，我们将详细了解 SageMaker Autopilot 如何处理数据并训练模型。如果现在感觉太高级，可以跳过这些内容。等你对该服务有了更多经验后，可以随时回头再看。

首先，让我们来看一下 SageMaker Autopilot 生成的工件。

作业工件

列出我们的 S3 存储桶可以确认存在许多不同的工件：

$ aws s3 ls s3://sagemaker-us-east-2-123456789012/sagemaker/DEMO-autopilot/output/my-first-autopilot-job/

我们可以看到许多新的前缀。让我们来弄明白它们分别代表什么：

PRE data-processor-models/
PRE documentation/
PRE preprocessed-data/
PRE sagemaker-automl-candidates/
PRE transformed-data/
PRE tuning/
PRE validations/

preprocessed-data/tuning_data 前缀包含从输入数据集生成的训练和验证拆分。每个拆分进一步被分解成小的 CSV 块。
sagemaker-automl-candidates 前缀包含 10 个数据预处理脚本（dpp[0-9].py），每个管道一个。它还包含训练它们的代码（trainer.py），以及使用这 10 个生成模型中的每一个处理输入数据集的代码（sagemaker_serve.py）。最后但同样重要的是，它包含自动生成的笔记本。
data-processor-models 前缀包含通过 dpp 脚本训练的 10 个数据处理模型。
transformed-data 前缀包含训练和验证拆分的 10 个处理版本。
tuning 前缀包含在模型调优步骤中训练的实际模型。
documentation 前缀包含可解释性报告。

以下图表总结了这些工件之间的关系：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_021.jpg

图 3.21 – 总结 Autopilot 过程

在接下来的几节中，我们将看一下两个自动生成的笔记本，它们是 SageMaker Autopilot 中最重要的功能之一。

数据探索笔记本

一旦数据分析步骤完成，此笔记本可以在 Amazon S3 上使用。

第一部分，如下图所示，简单地显示了数据集的一个样本：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_022.jpg

图 3.22 – 查看数据集统计信息

如下截图所示，第二部分重点分析列：缺失值的百分比、唯一值的计数和描述性统计数据。例如，pdays 字段的最大值和中位数均为 999，这看起来很可疑。如上一章所述，999 确实是一个占位符值，意味着客户之前从未被联系过。

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_023.jpg

图 3.23 – 查看数据集统计信息

如你所见，这个笔记本为我们省去了计算这些统计数据的麻烦，我们可以利用它们快速检查数据集是否符合预期。

现在，让我们来看一下第二个笔记本。正如你将看到的，它非常具有洞察力！

候选生成笔记本

本笔记本包含了 10 个候选管道的定义，以及它们的训练方式。这是一个可运行的笔记本，高级实践者可以利用它重现 AutoML 过程，并不断优化实验。请注意，这完全是可选的！直接部署最佳模型并开始测试也是完全可以的。

话虽如此，让我们手动运行其中一个管道：

我们打开笔记本并通过点击右上角的导入笔记本链接保存一个可读写的副本。
然后，我们在SageMaker 设置部分运行单元格，以导入所有所需的工件和参数。

移动到候选管道部分，我们创建一个运行器对象，它将为选定的候选管道启动作业：

from sagemaker_automl import AutoMLInteractiveRunner, AutoMLLocalCandidate
automl_interactive_runner = AutoMLInteractiveRunner(AUTOML_LOCAL_RUN_CONFIG)

接着，我们添加第一个管道（dpp0）。笔记本告诉我们：“此数据转换策略首先使用RobustImputer转换’数值’特征（将缺失值转换为 nan），然后使用ThresholdOneHotEncoder转换’类别’特征。它将所有生成的特征合并并应用RobustStandardScaler。转换后的数据将用于调整 XGBoost 模型。”我们只需运行以下单元格来添加它：
```
automl_interactive_runner.select_candidate(
    {”data_transformer”: {
        ”name”: ”dpp0”,
        …
    }
)
```
如果你对RobustImputer或ThresholdOneHotEncoder的实现感到好奇，超链接将引导你到sagemaker_sklearn_extension模块中的相关源文件（https://github.com/aws/sagemaker-scikit-learn-extension/）。

这样，你可以准确理解数据是如何处理的。由于这些对象是基于 scikit-learn 对象构建的，它们应该会很快变得非常熟悉。例如，我们可以看到RobustImputer是建立在sklearn.impute.SimpleImputer之上的，并增加了额外的功能。同样，ThresholdOneHotEncoder是sklearn.preprocessing.OneHotEncoder的扩展。
浏览其他管道时，我们可以看到不同的处理策略和算法。你应该能看到在一些管道中使用的线性学习者算法。它是 SageMaker 中的内置算法之一，我们将在下一章进行讲解。你还应该能看到基于神经网络的mlp算法。
向下滚动，我们进入了dpp0.py脚本，并看到该模型将使用 XGBoost 算法进行训练。

点击dpp0超链接会打开脚本。正如预期的那样，我们看到它构建了一个 scikit-learn 变换器管道（不要与由预处理和训练作业组成的 SageMaker 管道混淆）。数值特征的缺失值被填补，而类别特征则被进行独热编码。接下来，所有特征都被缩放，标签也被编码：

numeric_processors = Pipeline(
  steps=[('robustimputer',
         RobustImputer(strategy='constant',fill_values=nan))]
)
categorical_processors = Pipeline(
  steps=[('thresholdonehotencoder', 
         ThresholdOneHotEncoder(threshold=301))]
)
column_transformer = ColumnTransformer(
  transformers=[
    ('numeric_processing', numeric_processors, numeric),
    ('categorical_processing', categorical_processors,   
     categorical)]
)
return Pipeline(steps=[
  ('column_transformer', column_transformer),   
  ('robuststandardscaler', RobustStandardScaler())]
)

回到笔记本中，我们在运行数据转换步骤部分启动此脚本：
```
automl_interactive_runner.fit_data_transformers(parallel_jobs=7)
```

这将创建两个顺序执行的 SageMaker 作业，其工件将存储在为笔记本运行创建的新前缀中：

dpp0 transformers on the input dataset.The second job processes the input dataset with the resulting model. For the record, this job uses the SageMaker **Batch Transform** feature, which will be covered in a later chapter.

返回到 SageMaker Studio，让我们进一步了解这两个作业。从my-first-a-notebook-run-24-13-17-22-dpp0-train-24-13-38-38-aws-training-job和my-first-a-notebook-run-24-13-17-22-dpp0-transform-24-13-38-38-aws-transform-job开始。
双击作业名称会打开试验详情窗口，如下截图所示。它告诉我们关于作业的所有信息：参数、工件的位置等等：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_03_025.jpg

图 3.25 – 描述一个试验

一旦数据处理完成，笔记本将继续进行自动模型调优和模型部署。我们还没有讨论这些主题，所以现在先停在这里。等你对这些内容熟悉后，建议你继续阅读笔记本的其余部分。

总结

正如你所看到的，Amazon SageMaker Autopilot 使得初学者和高级用户都能轻松构建、训练和优化机器学习模型。

在本章中，你了解了 Autopilot 作业的不同步骤，以及它们从机器学习角度的含义。你还学会了如何使用 SageMaker Studio 图形用户界面和 SageMaker SDK 构建一个分类模型，几乎不需要编写代码。然后，我们深入探讨了自动生成的笔记本，这些笔记本让你对建模过程拥有完全的控制权和透明度。特别是，你学会了如何手动运行候选生成笔记本，以重播所有涉及的步骤。

在下一章中，你将学习如何使用 Amazon SageMaker 中的内置算法，训练模型以解决各种机器学习问题。

第四章：训练机器学习模型

在上一章中，你学习了 Amazon SageMaker Autopilot 如何让你轻松构建、训练和自动优化模型，而无需编写一行机器学习代码。

对于 SageMaker Autopilot 不支持的问题类型，下一最佳选择是使用 SageMaker 中已实现的算法之一，并在你的数据集上进行训练。这些算法被称为 内置算法，它们涵盖了许多典型的机器学习问题，从分类到时间序列到异常检测。

在本章中，你将学习适用于监督学习和无监督学习的内置算法，了解你可以用它们解决什么类型的问题，以及如何使用 SageMaker SDK 来使用它们：

发现 Amazon SageMaker 中的内置算法
使用内置算法训练和部署模型
使用 SageMaker SDK 与内置算法
使用更多内置算法

技术要求

你需要一个 AWS 账户才能运行本章中的示例。如果你还没有账户，请访问 aws.amazon.com/getting-started/ 创建一个。你还应该熟悉 AWS 免费套餐 (aws.amazon.com/free/)，它让你在某些使用限制内免费使用许多 AWS 服务。

你需要为你的账户安装并配置 AWS 命令行界面（CLI） (aws.amazon.com/cli/)。

你需要一个工作中的 Python 3.x 环境。安装 Anaconda 发行版 (www.anaconda.com/) 不是强制性的，但强烈推荐，因为它包含了我们将需要的许多项目（Jupyter，pandas，numpy 等）。

本书中包含的代码示例可在 GitHub 上找到：github.com/PacktPublishing/Learn-Amazon-SageMaker-second-edition。你需要安装 Git 客户端才能访问它们 (git-scm.com/)。

发现 Amazon SageMaker 中的内置算法

内置算法是由亚马逊实现的机器学习算法，在某些情况下是由亚马逊发明的 (docs.aws.amazon.com/sagemaker/latest/dg/algos.html)。它们让你在无需编写一行机器学习代码的情况下，快速训练和部署自己的模型。实际上，由于训练和预测代码是现成的，你无需担心实现它，能够专注于眼前的机器学习问题。像往常一样，SageMaker 完全管理基础设施，节省你更多的时间。

在本节中，您将了解传统机器学习问题的内置算法。计算机视觉和自然语言处理相关的算法将在接下来的两章中介绍。

有监督学习

有监督学习专注于需要标记数据集的问题，如回归或分类：

线性学习器构建线性模型来解决回归问题以及分类问题（包括二分类和多分类）。
因式分解机构建线性模型来解决回归问题以及分类问题（包括二分类和多分类）。因式分解机是线性模型的推广，特别适用于高维稀疏数据集，如推荐系统中的用户-物品交互矩阵。
K 最近邻（KNN）构建非参数模型用于回归和分类问题。
XGBoost构建回归、分类和排序问题的模型。XGBoost 可能是当前使用最广泛的机器学习算法，SageMaker 使用的是github.com/dmlc/xgboost提供的开源实现。
DeepAR构建多变量时间序列的预测模型。DeepAR 是基于循环神经网络的亚马逊发明算法，您可以通过arxiv.org/abs/1704.04110了解更多信息。
Object2Vec从通用高维对象中学习低维嵌入。Object2Vec 是由亚马逊发明的算法。
BlazingText构建文本分类模型。这个算法由亚马逊发明，您可以通过dl.acm.org/doi/10.1145/3146347.3146354了解更多信息。

无监督学习

无监督学习不需要标记数据集，涉及的问题包括聚类或异常检测：

K 均值构建聚类模型。SageMaker 使用了一个修改版的网页规模 K 均值聚类算法（www.eecs.tufts.edu/~dsculley/papers/fastkmeans.pdf）。
主成分分析（PCA）构建降维模型。
随机切割森林构建异常检测模型。
IP 洞察构建模型以识别 IPv4 地址的使用模式。这对于监控、网络安全等领域非常有用。
BlazingText计算词向量，这对于自然语言处理任务非常有用。

本章剩余部分将详细介绍其中一些算法。

关于可扩展性

在我们深入了解如何使用这些算法进行模型训练和部署之前，您可能会想知道为什么要使用它们，而不是使用像scikit-learn和R等著名库中的算法。

首先，这些算法已经由亚马逊团队实现并调优，亚马逊团队可不是机器学习的新人！大量的工作已经投入到确保这些算法在 AWS 基础设施上尽可能快速运行，无论你使用什么类型的实例。此外，许多算法支持分布式训练，让你可以将模型训练分布到一个完全托管的实例集群中。

正因如此，基准测试表明，这些算法通常比竞争对手的实现要好 10 倍。在许多情况下，它们也更具成本效益。你可以在以下网址了解更多信息：

AWS 特拉维夫峰会 2018：通过内置算法加速你的机器学习工作流程：www.youtube.com/watch?v=IeIUr78OrE0
亚马逊中的弹性机器学习算法，Liberty 等，SIGMOD’20：SageMaker：www.amazon.science/publications/elastic-machine-learning-algorithms-in-amazon-sagemaker

当然，这些算法也受益于 SageMaker 中的所有功能，正如你在本书的结尾部分会发现的那样。

使用内置算法训练和部署模型

Amazon SageMaker 让你以多种不同配置训练和部署模型。虽然它鼓励最佳实践，但它是一个模块化的服务，允许你按照自己的方式操作。

在本节中，我们将首先看看一个典型的端到端工作流程，展示如何从数据上传到模型部署，使用 SageMaker。然后，我们将讨论替代工作流程，以及如何根据需要挑选所需的功能。最后，我们将深入了解，从基础设施的角度看，当我们训练和部署时会发生什么。

理解端到端工作流程

让我们看看一个典型的 SageMaker 工作流程。你会在我们的示例中反复看到它，也会在 GitHub 上提供的 AWS 笔记本中看到它（github.com/awslabs/amazon-sagemaker-examples/）：

protobuf (developers.google.com/protocol-buffers)。
配置训练任务：在这里，你可以选择想要训练的算法，设置超参数，并定义训练任务的基础设施要求。
启动训练任务：在这里，我们传入你在 S3 中的数据集位置。训练发生在托管的基础设施上，系统会根据你的需求自动创建和配置。一旦训练完成，模型工件会被保存在 S3 中。训练基础设施会自动终止，你只需为实际使用的部分付费。
部署模型：你可以将模型部署到 实时 HTTPS 端点 进行实时预测，或部署到 批量转换 中。同样，你只需要定义基础设施要求。
预测数据：可以调用实时端点或批量转换器。正如你所期望的，这里的基础设施也已托管。对于生产环境，你还需要监控数据和预测的质量。
清理！：这涉及关闭端点，以避免不必要的费用。

理解这个工作流程对于提高 Amazon SageMaker 的生产力至关重要。幸运的是，SageMaker SDK 提供了与这些步骤高度匹配的简单 API，因此你不必担心该使用哪个 API，或者何时使用它。

在我们开始查看 SDK 之前，让我们考虑一些在你的业务和技术环境中可能有意义的替代工作流。

使用替代工作流

Amazon SageMaker 是一个模块化的服务，允许你按自己的方式工作。让我们首先考虑一个工作流，其中你会在 SageMaker 上进行训练，并在你自己的服务器上进行部署，无论原因是什么。

导出模型

步骤 1-3 与前面的示例相同，然后你可以做如下操作：

从 S3 下载训练工件，它以 model.tar.gz 文件的形式存在。
提取存储在工件中的模型。
在你自己的服务器上，使用适当的机器学习库加载模型：
- fastText 实现可以在 fasttext.cc/ 获取。
- 对于所有其他模型：使用 Apache MXNet (mxnet.apache.org/)。

现在，让我们看看如何将现有模型导入并部署到 SageMaker 上。

导入模型

步骤同样简单：

将你的模型打包成模型工件（model.tar.gz）。
将工件上传到 S3 桶。
将工件注册为 SageMaker 模型。
部署模型并进行预测。

这只是一个快速的概览。我们将在 第十一章，部署机器学习模型 中为这两个工作流运行完整的示例。

使用完全托管的基础设施

所有 SageMaker 作业都在托管基础设施上运行。让我们看看背后的工作原理，看看训练和部署模型时发生了什么。

将算法打包到 Docker 容器中

所有 SageMaker 算法必须打包在 Docker 容器中。别担心，使用 SageMaker 并不需要你对 Docker 有太多了解。如果你不熟悉 Docker，建议你阅读这个教程，以了解关键概念和工具：docs.docker.com/get-started/。多了解一点总是有好处的！

正如您所预期的，内置算法已经打包好，并且容器随时可用于训练和部署。它们托管在Amazon Elastic Container Registry（ECR）中，这是 AWS 的 Docker 注册服务 (aws.amazon.com/ecr/)。由于 ECR 是一个基于区域的服务，您会在每个 SageMaker 可用的区域找到一系列容器。

您可以在 docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html 找到内置算法容器的列表。例如，在 eu-west-1 区域，Linear Learner 算法的容器名称是 438346466558.dkr.ecr.eu-west-1.amazonaws.com/linear-learner:latest。这些容器只能拉取到 SageMaker 管理的实例中，因此您无法在本地计算机上运行它们。

现在，让我们来看一下底层基础设施。

创建训练基础设施

当您启动训练作业时，SageMaker 会根据您的需求（实例类型和实例数量）启动基础设施。

一旦训练实例投入使用，它会从 ECR 拉取适当的训练容器。超参数会应用到算法上，算法也会接收到数据集的位置。默认情况下，算法会从 S3 复制完整的数据集并开始训练。如果配置了分布式训练，SageMaker 会自动将数据集批次分发到集群中的不同实例。

训练完成后，模型会被打包成模型工件并保存在 S3 中。然后，训练基础设施会自动关闭。日志可以在Amazon CloudWatch Logs中查看。最后但同样重要的是，您只会按实际的训练时间收费。

创建预测基础设施

当您启动部署作业时，SageMaker 会根据您的需求再次创建基础设施。

现在让我们暂时专注于实时终端节点，而不关注批量转换。

一旦终端节点实例投入使用，它会从 ECR 拉取适当的预测容器，并从 S3 加载您的模型。然后，HTTPS 端点会被配置好，并在几分钟内准备好进行预测。

如果您配置了多个实例的终端节点，负载均衡和高可用性将自动设置。如果您配置了自动扩展，也会应用此设置。

正如您所预期的，终端节点会保持开启状态，直到显式删除它，无论是在 AWS 控制台中，还是通过 SageMaker API 调用。在此期间，您将为终端节点付费，因此请确保删除不再需要的终端节点！

现在我们了解了大致情况，让我们开始了解 SageMaker SDK，看看如何使用它来训练和部署模型。

使用内置算法的 SageMaker SDK

熟悉 SageMaker SDK 对于充分利用 SageMaker 至关重要。您可以在sagemaker.readthedocs.io找到其文档。

通过一个简单的示例入手是最好的开始方式。在本节中，我们将使用 Linear Learner 算法在波士顿房价数据集上训练回归模型（www.kaggle.com/c/boston-housing）。我们将非常慢地进行，每一步都不遗漏。再次强调，这些概念非常重要，请花时间理解每一个步骤。

提醒

我建议您跟随并运行伴随 GitHub 仓库中的代码。我们已尽一切努力检查文中所有代码示例。然而，对于电子版的用户，复制粘贴可能会导致不可预测的结果：格式问题、奇怪的引号等。

数据准备

内置算法要求数据集必须符合特定格式，例如CSV、protobuf或libsvm。支持的格式可以在算法文档中找到。例如，Linear Learner 支持 CSV 和 RecordIO 包装的 protobuf（docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html#ll-input_output）。

我们的输入数据集已经以 CSV 格式存储在仓库中，因此我们将使用它。数据集准备将极为简单，我们将手动运行它：

使用pandas，我们用 pandas 加载 CSV 数据集：

import pandas as pd
dataset = pd.read_csv('housing.csv')

然后，我们打印数据集的形状：
```
print(dataset.shape)
```
它包含 506 个样本和 13 列：
```
(506, 13)
```
现在，我们显示数据集的前 5 行：
```
dataset[:5]
```
这将输出以下图中可见的表格。对于每个房子，我们可以看到 12 个特征，以及一个目标属性（medv），该属性是房子的中位数价格（以千美元为单位）：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_1.jpg

图 4.1 – 查看数据集
阅读算法文档（docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html），我们看到Amazon SageMaker 要求 CSV 文件没有头部记录，且目标变量必须位于第一列。因此，我们将medv列移动到数据框的最前面：
```
dataset = pd.concat([dataset['medv'],
                     dataset.drop(['medv'], axis=1)], 
                     axis=1)
```

一些scikit-learn的魔法帮助我们将数据框分为两部分——90%用于训练，10%用于验证：

from sklearn.model_selection import train_test_split
training_dataset, validation_dataset =  
    train_test_split(dataset, test_size=0.1)

我们将这两个拆分保存为单独的 CSV 文件，不包含索引或头部：

training_dataset.to_csv('training_dataset.csv', 
                        index=False, header=False)
validation_dataset.to_csv('validation_dataset.csv', 
                          index=False, header=False)

现在，我们需要将这两个文件上传到 S3。我们可以使用任何桶，在这里我们将使用 SageMaker 在我们运行的区域自动创建的默认桶。我们可以通过sagemaker.Session.default_bucket() API 查找其名称：
```
import sagemaker
sess = sagemaker.Session()
bucket = sess.default_bucket()
```

最后，我们使用 sagemaker.Session.upload_data() API 将两个 CSV 文件上传到默认存储桶。这里，训练和验证数据集每个由一个文件组成，但如果需要，我们也可以上传多个文件。因此，我们必须将数据集上传到不同的 S3 前缀下，以避免文件混淆：

prefix = 'boston-housing'
training_data_path = sess.upload_data(
    path='training_dataset.csv', 
    key_prefix=prefix + '/input/training')
validation_data_path = sess.upload_data(
    path='validation_dataset.csv', 
    key_prefix=prefix + '/input/validation')
print(training_data_path)
print(validation_data_path)

这两个 S3 路径如下所示。自然，默认存储桶名称中的账户号码会有所不同：

s3://sagemaker-eu-west-1-123456789012/boston-housing/input/training/training_dataset.csv
s3://sagemaker-eu-west-1-123456789012/boston-housing/input/validation/validation_dataset.csv

现在数据已经准备好在 S3 中，我们可以配置训练任务。

配置训练任务

Estimator 对象（sagemaker.estimator.Estimator）是模型训练的基石。它让你选择适当的算法，定义你的训练基础设施要求等。

SageMaker SDK 还包括特定算法的估算器，例如 sagemaker.LinearLearner 或 sagemaker.PCA。我通常认为它们不如通用估算器灵活（例如不支持 CSV 格式），并且不推荐使用它们。使用 Estimator 对象还可以让你在不同示例之间重用代码，正如我们在接下来的章节中所看到的：

在本章之前，我们学习了 SageMaker 算法是打包在 Docker 容器中的。通过使用 boto3 和 image_uris.retrieve() API，我们可以轻松找到我们运行的区域中 Linear Learner 算法的名称：
```
from sagemaker import get_execution_role
from sagemaker.image_uris import retrieve
region = sess.boto_session.region_name
container = retrieve('linear-learner', region)
```
现在我们知道了容器的名称，我们可以使用 Estimator 对象来配置我们的训练任务。除了容器名称外，我们还需要传递 SageMaker 实例将使用的 IAM 角色、用于训练的实例类型和实例数量，以及模型的输出位置。Estimator 会自动生成一个训练任务，我们还可以通过 base_job_name 参数设置自己的前缀：
```
from sagemaker.estimator import Estimator
ll_estimator = Estimator(
    container,
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='ml.m5.large',
    output_path='s3://{}/{}/output'.format(bucket, 
                                           prefix))
```
SageMaker 支持多种不同类型的实例，不同的 AWS 区域之间有所差异。你可以在 docs.aws.amazon.com/sagemaker/latest/dg/instance-types-az.html 查看完整列表。

我们应该选择哪个呢？查看 Linear Learner 文档 (docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html#ll-instances)，我们看到 你可以在单机或多机 CPU 和 GPU 实例上训练 Linear Learner 算法。在这里，我们处理的是一个小数据集，因此让我们选择我们所在区域中最小的训练实例：ml.m5.large。

查看定价页面 (aws.amazon.com/sagemaker/pricing/)，我们看到这个实例在 eu-west-1 区域的费用是每小时 $0.128（我为此任务使用的区域）。
接下来，我们需要设置 predictor_type。它定义了 Linear Learner 训练的目标问题类型（回归、二分类或多分类）。

更深入地查看，我们发现mini_batch_size的默认值是 1000：对于我们 506 个样本的数据集，这个值并不适合，因此我们将其设置为 32。我们还发现normalize_data参数默认设置为 true，这使得我们不需要自己进行数据标准化：
```
ll_estimator.set_hyperparameters(
    predictor_type='regressor', 
    mini_batch_size=32)
```
现在，让我们定义数据通道：通道是传递给 SageMaker 估算器的命名数据源。所有内置算法至少需要一个训练通道，许多算法还接受用于验证和测试的额外通道。在这里，我们有两个通道，它们都提供 CSV 格式的数据。TrainingInput() API 让我们定义数据的位置、格式、是否压缩等：
```
from sagemaker import TrainingInput
training_data_channel = TrainingInput(
    s3_data=training_data_path, 
    content_type='text/csv')
validation_data_channel = TrainingInput(
    s3_data=validation_data_path,  
    content_type='text/csv')
```
默认情况下，通道提供的数据会完全复制到每个训练实例，这对于小数据集来说没问题。在第十章《高级训练技术》中，我们将研究其他方法。

一切准备就绪，接下来我们启动训练任务。

启动训练任务

只需要一行代码：

我们只需将包含两个通道的 Python 字典传递给fit() API：

ll_estimator.fit(
    {'train': training_data_channel, 
     'validation': validation_data_channel})

训练任务立即开始：

Starting - Starting the training job.

一旦任务启动，它就会出现在SageMaker 组件和注册表 | 实验和试验面板中。在那里，你可以看到所有任务的元数据：数据集的位置、超参数等。
训练日志在笔记本中可见，同时也存储在 Amazon CloudWatch Logs 中，路径为/aws/sagemaker/TrainingJobs。这里是前几行，显示了基础设施的配置过程，如前面在使用完全托管的基础设施部分所解释的：
```
Starting - Starting the training job...
Starting - Launching requested ML instances......
Starting - Preparing the instances for training...
Downloading - Downloading input data...
Training - Training image download completed.
```

在训练日志的末尾，我们看到有关均方误差（MSE）和损失指标的信息：

#quality_metric: host=algo-1, validation mse <loss>=13.7226685169
#quality_metric: host=algo-1, validation absolute_loss <loss>=2.86944983987

训练完成后，模型会自动复制到 S3，SageMaker 会告诉我们训练任务花费的时间：

ml.m5.large instance is $0.128 per hour. As we trained for 49 seconds, this job cost us (49/3600)*0.128= $0.00174 – less than a fifth of a penny. Any time spent setting up infrastructure ourselves would have certainly cost more!

查看 S3 存储桶中的输出位置，我们看到了模型工件：
```
model.tar.gz.
```

我们将在第十一章，《部署机器学习模型》中，了解该工件内部的内容以及如何在 SageMaker 外部部署模型。现在，我们将模型部署到实时端点。

部署模型

这是我最喜欢的 SageMaker 部分；我们只需要一行代码就能将模型部署到HTTPS 端点：

最好的做法是创建可识别且唯一的端点名称。我们也可以在部署时让 SageMaker 为我们创建一个端点名称：
```
from time import strftime, gmtime
timestamp = strftime('%d-%H-%M-%S', gmtime())
endpoint_name = 'linear-learner-demo-'+timestamp
print(endpoint_name)
```
这里，端点名称是linear-learner-demo-29-08-37-25。
我们使用deploy() API 部署模型。由于这是一个测试端点，我们使用可用的最小端点实例ml.t2.medium。在欧盟西部 1 区，这将仅花费我们每小时 0.07 美元：
```
ll_predictor = ll_estimator.deploy(
    endpoint_name=endpoint_name,
    initial_instance_count=1,
    instance_type='ml.t2.medium')
```
当端点创建完成后，我们可以在SageMaker 组件和注册表 | 端点面板中看到它：

几分钟后，端点开始服务。我们可以使用 predict() API 发送一个 CSV 样本进行预测。我们使用内置函数设置序列化：

ll_predictor.serializer =   
    sagemaker.serializers.CSVSerializer()
ll_predictor.deserializer =
    sagemaker.deserializers.CSVDeserializer()
test_sample = '0.00632,18.00,2.310,0,0.5380,6.5750,65.20,4.0900,1,296.0,15.30,4.98'
response = ll_predictor.predict(test_sample)
print(response)

预测输出告诉我们，这栋房子的预计价格为 $30,173：

 [['30.17342185974121']]

我们还可以一次预测多个样本：

test_samples = [
'0.00632,18.00,2.310,0,0.5380,6.5750,65.20,4.0900,1,296.0,15.30,4.98',
'0.02731,0.00,7.070,0,0.4690,6.4210,78.90,4.9671,2,242.0,17.80,9.14']
response = ll_predictor.predict(test_samples)
print(response)

现在预测输出如下：

 [['30.413358688354492'],['24.884408950805664']]

当我们完成端点的工作时，我们不应忘记删除它以避免不必要的费用。

清理工作

删除端点就像调用 delete_endpoint() API 一样简单：

ll_predictor.delete_endpoint()

再次重申，本节涵盖的主题非常重要，请确保您完全熟悉它们，因为我们将在本书的其余部分经常使用它们。请花些时间阅读服务和 SDK 文档：

现在让我们探索其他内置算法。您将看到工作流程和代码非常相似！

使用更多内置算法：

在本章的其余部分，我们将使用内置算法运行更多示例，包括监督和无监督模式。这将帮助您非常熟悉 SageMaker SDK，并学习如何解决实际的机器学习问题。以下列表显示了其中一些算法：

使用 XGBoost 进行分类：
使用因子分解机进行推荐：
使用 PCA 进行降维：
使用 Random Cut Forest 进行异常检测：

使用 XGBoost 进行回归：

让我们使用 XGBoost 算法在波士顿房屋数据集上训练模型（github.com/dmlc/xgboost）。正如我们将在 第七章 中看到的，使用内置框架扩展机器学习服务，SageMaker 也支持 XGBoost 脚本：

我们重复了前面示例中的数据集准备步骤。

我们找到 XGBoost 容器的名称。由于支持多个版本，我们选择最新版本（写作时为 1.3.1）：

from sagemaker import image_uris
region = sess.boto_session.region_name     
container = image_uris.retrieve('xgboost', region, 
                                version='latest')

我们配置 Estimator 函数。代码与使用 LinearLearner 时完全相同：

xgb_estimator = Estimator(
   container,
   role=sagemaker.get_execution_role(),
   instance_count=1,
   instance_type='ml.m5.large',
   output_path='s3://{}/{}/output'.format(bucket, 
                                          prefix))

查看超参数（docs.aws.amazon.com/sagemaker/latest/dg/xgboost_hyperparameters.html），我们看到唯一需要的是 num_round。因为不明确应设置哪个值，我们将选择一个较大的值，并且还会定义 early_stopping_rounds 参数以避免过拟合。当然，我们需要为回归问题设置目标：
```
xgb_estimator.set_hyperparameters(
    objective='reg:linear',
    num_round=200,
    early_stopping_rounds=10)
```

我们定义训练输入，就像前面的示例一样：

from sagemaker import TrainingInput
training_data_channel = TrainingInput(
    s3_data=training_data_path, 
    content_type='text/csv')
validation_data_channel = TrainingInput(
    s3_data=validation_data_path,  
    content_type='text/csv')

然后我们启动训练作业：

xgb_estimator.fit(
    {'train': training_data_channel, 
     'validation': validation_data_channel})

任务只运行了 22 轮，这意味着触发了早停。从训练日志中看到，第 12 轮实际上是最佳的，均方根误差（RMSE）为 2.43126：
```
[12]#011train-rmse:1.25702#011validation-rmse:2.43126
<output removed>
[22]#011train-rmse:0.722193#011validation-rmse:2.43355
```

部署仍然只需要一行代码：

from time import strftime, gmtime
timestamp = strftime('%d-%H-%M-%S', gmtime())
endpoint_name = 'xgb-demo'+'-'+timestamp
xgb_predictor = xgb_estimator.deploy(
    endpoint_name=endpoint_name,
    initial_instance_count=1,
    instance_type='ml.t2.medium')

一旦模型部署完成，我们再次使用predict() API 发送一个 CSV 样本：

test_sample = '0.00632,18.00,2.310,0,0.5380,6.5750,65.20,4.0900,1,296.0,15.30,4.98'
xgb_predictor.serializer =
    sagemaker.serializers.CSVSerializer()
xgb_predictor.deserializer =
    sagemaker.deserializers.CSVDeserializer()
response = xgb_predictor.predict(test_sample)
print(response)

结果告诉我们，这套房子应该值 23,754 美元：

[['23.73023223876953']]

最后，当我们完成任务时，删除端点：
```
xgb_predictor.delete_endpoint()
```

如你所见，SageMaker 的工作流程非常简单，使我们能够快速地尝试不同的算法，而无需重写所有代码。

让我们继续讲解因式分解机算法。在这个过程中，我们将了解高效的 RecordIO 封装 protobuf 格式。

使用因式分解机进行推荐

因式分解机是线性模型的广义化（www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf）。它非常适合高维稀疏数据集，如推荐系统中的用户-物品交互矩阵。

在这个示例中，我们将基于MovieLens数据集训练一个推荐模型（grouplens.org/datasets/movielens/）。

该数据集有多个版本。为了减少训练时间，我们将使用 100k 版本。它包含 943 个用户对 1,682 部电影的 100,000 条评分（评分值从 1 到 5）。数据集已经划分为训练集和验证集。

正如你现在所知道的，使用 SageMaker 进行训练和部署非常简单。大部分代码将与之前的两个示例完全相同，这很棒！这样我们可以专注于理解和准备数据。

理解稀疏数据集

想象构建一个矩阵来存储这个数据集。它会有 943 行（每行代表一个用户）和 1,682 列（每列代表一部电影）。单元格中存储评分。下图展示了一个基本的示例：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_2.jpg

图 4.2 – 稀疏矩阵

因此，矩阵将有 943*1,682=1,586,126 个单元格。然而，由于只有 100,000 条评分，93.69%的单元格将是空的。以这种方式存储数据集将非常低效，浪费 RAM、存储和网络带宽来存储和传输大量零值！

事实上，情况更糟，因为算法希望输入数据集看起来像下图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_3.jpg

图 4.3 – 稀疏矩阵

为什么我们需要以这种方式存储数据？答案很简单：因式分解机是一个监督学习算法，所以我们需要用带标签的样本来训练它。

从前面的图示可以看到，每一行代表一个电影评分。左边的矩阵存储它的独热编码特征（用户和电影），而右边的向量存储它的标签。例如，最后一行告诉我们，用户 4 给电影 5 打了“5”分。

这个矩阵的大小是 100,000 行和 2,625 列（943 部电影加 1,682 部电影）。总共有 262,500,000 个单元格，其中只有 0.076% 被填充（200,000 / 262,500,000）。如果我们为每个单元格使用一个 32 位的值，我们需要接近一 GB 的内存来存储这个矩阵。这非常低效，但仍然可以管理。

为了好玩，让我们以 MovieLens 的最大版本为例，它有 2500 万条评分，62,000 部电影和 162,000 名用户。这个矩阵将有 2500 万行和 224,000 列，总共 5,600,000,000,000 个单元格。是的，这是 5.6 万亿个单元格，尽管它们有 99.999% 是空的，但我们仍然需要超过 20 TB 的内存来存储它们。哎呀。如果这还不够糟糕，想想推荐模型，它们有数百万的用户和产品：这些数字令人咋舌！

我们不会使用普通的矩阵，而是使用一个 SciPy 提供的对象，名为 lil_matrix （docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.lil_matrix.html）。这将帮助我们去除所有这些讨厌的零。

理解 protobuf 和 RecordIO

那么，我们如何将这个稀疏矩阵传递给 SageMaker 算法呢？正如你所预期的，我们将序列化这个对象并将其存储在 S3 中。但我们不会使用 Python 的序列化方法。相反，我们将使用 protobuf （developers.google.com/protocol-buffers/），这是一种流行且高效的序列化机制。

此外，我们将把 protobuf 编码的数据存储在一种名为 RecordIO 的记录格式中（mxnet.apache.org/api/faq/recordio/）。我们的数据集将作为一系列记录存储在单个文件中。这有以下几个好处：

单个文件更容易移动：谁想处理成千上万的单独文件，这些文件可能会丢失或损坏呢？
顺序文件读取速度更快，这使得训练过程更加高效。
一系列记录便于分割用于分布式训练。

如果你不熟悉 protobuf 和 RecordIO，不用担心。SageMaker SDK 包含隐藏其复杂性的实用函数。

在 MovieLens 上构建因式分解机模型

我们将按照以下步骤开始构建模型：

在 Jupyter notebook 中，我们首先下载并提取 MovieLens 数据集：

%%sh
wget http://files.grouplens.org/datasets/movielens/ml-100k.zip
unzip ml-100k.zip

由于数据集是按用户 ID 排序的，我们进行了一次洗牌作为预防措施。然后，我们查看前几行：
```
%cd ml-100k
!shuf ua.base -o ua.base.shuffled
!head -5 ua.base.shuffled
```
我们看到了四列：用户 ID、电影 ID、评分和时间戳（我们将在模型中忽略时间戳）：
```
378  43  3  880056609
919  558 5  875372988
90   285 5  891383687
249  245 2  879571999
416  64  5  893212929
```

我们定义了大小常数：

num_users = 943
num_movies = 1682
num_features = num_users+num_movies
num_ratings_train = 90570
num_ratings_test = 9430

现在，让我们编写一个函数，将数据集加载到稀疏矩阵中。根据之前的解释，我们逐行遍历数据集。在 X 矩阵中，我们将相应的用户和电影列设置为 1。我们还将评分存储在 Y 向量中：

import csv
import numpy as np
from scipy.sparse import lil_matrix
def loadDataset(filename, lines, columns):
    X = lil_matrix((lines, columns)).astype('float32')
    Y = []
    line=0
    with open(filename,'r') as f:
        samples=csv.reader(f,delimiter='\t')
        for userId,movieId,rating,timestamp in samples:
            X[line,int(userId)-1] = 1
            X[line,int(num_users)+int(movieId)-1] = 1
            Y.append(int(rating))
            line=line+1       
    Y=np.array(Y).astype('float32')
    return X,Y

然后，我们处理训练集和测试集：

X_train, Y_train = loadDataset('ua.base.shuffled', 
                               num_ratings_train,  
                               num_features)
X_test, Y_test = loadDataset('ua.test',
                             num_ratings_test, 
                             num_features)

我们检查形状是否符合预期：

print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)

这将显示数据集的形状：

(90570, 2625)
(90570,)
(9430, 2625)
(9430,)

现在，让我们编写一个函数，将数据集转换为 RecordIO 封装的 protobuf 格式，并将其上传到 S3 桶中。我们首先使用 io.BytesIO() 创建一个内存中的二进制流。然后，我们使用至关重要的 write_spmatrix_to_sparse_tensor() 函数，将样本矩阵和标签向量以 protobuf 格式写入该缓冲区。最后，我们使用 boto3 将缓冲区上传到 S3：
```
import io, boto3
import sagemaker.amazon.common as smac
def writeDatasetToProtobuf(X, Y, bucket, prefix, key):
    buf = io.BytesIO()
    smac.write_spmatrix_to_sparse_tensor(buf, X, Y)
    buf.seek(0)
    obj = '{}/{}'.format(prefix, key)  

    boto3.resource('s3').Bucket(bucket).Object(obj).
    upload_fileobj(buf)
    return 's3://{}/{}'.format(bucket,obj)
```
如果我们的数据存储在 numpy 数组中，而不是 lilmatrix，我们将使用 write_numpy_to_dense_tensor() 函数。它的效果是一样的。

我们将此函数应用于两个数据集，并存储它们的 S3 路径：

import sagemaker
sess   = sagemaker.Session()
bucket = sess.default_bucket()
prefix = 'fm-movielens'
train_key      = 'train.protobuf'
train_prefix   = '{}/{}'.format(prefix, 'train')
test_key       = 'test.protobuf'
test_prefix    = '{}/{}'.format(prefix, 'test')
output_prefix  = 's3://{}/{}/output'.format(bucket, 
                                            prefix)
train_data = writeDatasetToProtobuf(X_train, Y_train, 
             bucket, train_prefix, train_key)    
test_data  = writeDatasetToProtobuf(X_test, Y_test, 
             bucket, test_prefix, test_key)

在终端查看 S3 桶时，我们看到训练数据集仅占用 5.5 MB。稀疏矩阵、protobuf 和 RecordIO 的结合取得了效果：
```
$ aws s3 ls s3://sagemaker-eu-west-1-123456789012/fm-movielens/train/train.protobuf
5796480 train.protobuf
```

接下来的过程是 SageMaker 的常规操作。我们找到分解机容器的名称，配置 Estimator 函数，并设置超参数：

from sagemaker.image_uris import retrieve
region = sess.boto_session.region_name    
container=retrieve('factorization-machines', region)
fm=sagemaker.estimator.Estimator(
    container,
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='ml.c5.xlarge',
    output_path=output_prefix)
fm.set_hyperparameters(
    feature_dim=num_features,
    predictor_type='regressor',
    num_factors=64,
    epochs=10)

查阅文档（docs.aws.amazon.com/sagemaker/latest/dg/fact-machines-hyperparameters.html），我们看到所需的超参数为 feature_dim、predictor_type 和 num_factors。epochs 的默认设置为 1，这感觉有点低，因此我们将其设置为 10。

然后，我们启动训练作业。你有没有注意到我们没有配置训练输入？我们只是传递了两个 protobuf 文件的位置。由于 protobuf 是分解机（以及其他内置算法）的默认格式，我们可以省略这一步：
```
fm.fit({'train': train_data, 'test': test_data})
```

作业完成后，我们将模型部署到实时端点：

endpoint_name = 'fm-movielens-100k'
fm_predictor = fm.deploy(
    endpoint_name=endpoint_name,
    instance_type='ml.t2.medium', 
    initial_instance_count=1)

我们现在将以 JSON 格式（https://docs.aws.amazon.com/sagemaker/latest/dg/fact-machines.html#fm-inputoutput）将样本发送到端点。为此，我们编写一个自定义序列化器，将输入数据转换为 JSON。由于我们将内容类型设置为 'application/json'，默认的 JSON 反序列化器将自动使用：

import json
from sagemaker.deserializers import JSONDeserializer
from sagemaker.serializers import JSONSerializer
class FMSerializer(JSONSerializer):
    def serialize(self, data):
        js = {'instances': []}
        for row in data:
            js['instances'].append({'features':   
                            row.tolist()})
        return json.dumps(js)
fm_predictor.serializer = FMSerializer()
fm_predictor.deserializer = JSONDeserializer()

我们发送测试集的前三个样本进行预测：

result = fm_predictor.predict(X_test[:3].toarray())
print(result)

预测结果如下：

{'predictions': [{'score': 3.3772034645080566}, {'score': 3.4299235343933105}, {'score': 3.6053106784820557}]}

使用这个模型，我们可以填充推荐矩阵中的所有空白单元。对于每个用户，我们只需预测所有电影的评分，并存储，例如，排名前 50 的电影。这些信息将存储在后台，前端应用程序中将显示相应的元数据（如标题、类型等）。
最后，我们删除端点：
```
fm_predictor.delete_endpoint()
```

到目前为止，我们仅使用了监督学习算法。在接下来的部分，我们将转向使用主成分分析进行无监督学习。

使用主成分分析

在因子分解机示例中建立的protobuf数据集。它的 2,625 列非常适合降维！我们将采用 PCA，步骤如下：

从处理过的数据集开始，我们为 PCA 配置Estimator。现在，你应该（几乎）可以闭着眼睛做到这一点：

from sagemaker.image_uris import retrieve
region = sess.boto_session.region_name   
container = retrieve('pca', region) 
pca = sagemaker.estimator.Estimator(
    container=container,
    role=sagemaker.get_execution_role(),
    instance_count=1,                               
    instance_type='ml.c5.xlarge',
    output_path=output_prefix)

然后，我们设置超参数。必需的是初始特征数、计算主成分的数量以及批处理大小：

pca.set_hyperparameters(feature_dim=num_features,
                        num_components=64,
                        mini_batch_size=1024)

我们训练并部署模型：

pca.fit({'train': train_data, 'test': test_data})
pca_predictor = pca.deploy(
    endpoint_name='pca-movielens-100k',
    instance_type='ml.t2.medium',
    initial_instance_count=1)

然后，我们预测第一个测试样本，使用与前一个示例相同的序列化代码：

import json
from sagemaker.deserializers import JSONDeserializer
from sagemaker.serializers import JSONSerializer
class PCASerializer(JSONSerializer):
    def serialize(self, data):
        js = {'instances': []}
        for row in data:
            js['instances'].append({'features': 
                            row.tolist()})
        return json.dumps(js)
pca_predictor.serializer = PCASerializer()
pca_predictor.deserializer = JSONDeserializer()
result = pca_predictor.predict(X_test[0].toarray())
print(result)

这将打印出测试样本的 64 个主要成分。在实际生活中，我们通常会使用这个模型处理数据集，保存结果，并用它们来训练回归模型：

{'projections': [{'projection': [-0.008711372502148151, 0.0019895541481673717, 0.002355781616643071, 0.012406938709318638, -0.0069608548656105995, -0.009556426666676998, <output removed>]}]}

当你完成时别忘了删除端点。接着，让我们运行另一个无监督学习的例子来结束这一章节！

使用随机森林检测异常

随机森林 (RCF) 是一种用于异常检测的无监督学习算法（proceedings.mlr.press/v48/guha16.pdf）。我们将把它应用于家庭电力消耗数据集的一个子集（archive.ics.uci.edu/ml/），该数据集可在本书的 GitHub 仓库中获取。数据在接近一年的时间内按小时聚合（大约不到 8,000 个值）：

在 Jupyter 笔记本中，我们使用pandas加载数据集，并显示前几行：
```
import pandas as pd
df = pd.read_csv('item-demand-time.csv', dtype = object, names=['timestamp','value','client'])
df.head(3)
```
如下截图所示，数据集有三列 - 每小时时间戳、功耗值（以千瓦时计算）、客户 ID：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_4.jpg

图 4.4 – 查看列
使用matplotlib，我们绘制数据集以快速了解其外观：
```
import matplotlib
import matplotlib.pyplot as plt
df.value=pd.to_numeric(df.value)
df_plot=df.pivot(index='timestamp',columns='item',
                 values='value')
df_plot.plot(figsize=(40,10))
```
下图显示了绘图结果。我们看到三个时间序列对应于三个不同的客户：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_5.jpg

图 4.5 – 查看数据集
这个数据集存在两个问题。首先，它包含多个时间序列：RCF 只能在单个序列上训练模型。其次，RCF 需要pandas - 我们只保留了"client_12"时间序列，将其值乘以 100，并转换为整数类型：
```
df = df[df['item']=='client_12']
df = df.drop(['item', 'timestamp'], axis=1)
df.value *= 100
df.value = df.value.astype('int32')
df.head()
```
下图显示了转换后数据集的前几行：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_6.jpg

图 4.6 – 第一行的值
我们再次绘制它以检查它的预期外观。请注意在第 2000 步后的大幅下降，这在下图的框中得到了突出显示。这显然是一个异常，希望我们的模型能够捕捉到它：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_7.jpg

图 4.7 – 查看单一时间序列

与前面的示例一样，我们将数据集保存到 CSV 文件中，并上传到 S3：

import sagemaker
sess = sagemaker.Session()
bucket = sess.default_bucket()
prefix = 'electricity'
df.to_csv('electricity.csv', index=False, 
          header=False)
training_data_path = sess.upload_data(
                       path='electricity.csv', 
                       key_prefix=prefix + 
                                  '/input/training')

然后，我们定义 label_size=1）。即使训练通道从未包含标签，我们仍然需要告诉 RCF。

其次，唯一的 ShardedByS3Key。该策略将数据集跨训练集群中的不同实例进行拆分，而不是发送完整副本。我们不会在这里运行分布式训练，但仍然需要设置该策略：

training_data_channel = 
    sagemaker.TrainingInput(
        s3_data=training_data_path,                                                            
        content_type='text/csv;label_size=0',                                         
        distribution='ShardedByS3Key')
rcf_data = {'train': training_data_channel}

其余部分照常：训练并部署！我们再次重用前面示例中的代码，几乎没有改变：

from sagemaker.estimator import Estimator
from sagemaker.image_uris import retrieve
region = sess.boto_session.region_name
container = retrieve('randomcutforest', region)
rcf_estimator = Estimator(container,
    role= sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='ml.m5.large',
    output_path='s3://{}/{}/output'.format(bucket, 
                                           prefix))
rcf_estimator.set_hyperparameters(feature_dim=1)
rcf_estimator.fit(rcf_data)
endpoint_name = 'rcf-demo'
rcf_predictor = rcf_estimator.deploy(
    endpoint_name=endpoint_name,
    initial_instance_count=1,
    instance_type='ml.t2.medium')

几分钟后，模型已被部署。我们将输入的时间序列转换为 Python 列表，然后发送到端点进行预测。我们分别使用 CSV 和 JSON 进行序列化和反序列化：

rcf_predictor.serializer =
    sagemaker.serializers.CSVSerializer()
rcf_predictor.deserializer =
    sagemaker.deserializers.JSONDeserializer()
values = df['value'].astype('str').tolist()
response = rcf_predictor.predict(values)
print(response)

响应包含时间序列中每个值的异常分数。它看起来是这样的：

{'scores': [{'score': 1.0868037776}, {'score': 1.5307718138}, {'score': 1.4208102841} …

然后，我们将此响应转换为 Python 列表，并计算其均值和标准差：

from statistics import mean,stdev
scores = []
for s in response['scores']:
    scores.append(s['score'])
score_mean = mean(scores)
score_std = stdev(scores)

我们绘制时间序列的一个子集以及相应的分数。让我们集中关注 “[2000:2500]” 区间，因为这是我们看到大幅下降的地方。我们还绘制了代表均值加三倍标准差（得分分布的 99.7%）的线——任何大大超过该线的得分都可能是异常：
```
df[2000:2500].plot(figsize=(40,10))
plt.figure(figsize=(40,10))
plt.plot(scores[2000:2500])
plt.autoscale(tight=True)
plt.axhline(y=score_mean+3*score_std, color='red')
plt.show()
```
下降在以下图表中显而易见：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_8.jpg

图 4.8 – 聚焦于异常

如下图所示，其得分非常高！毫无疑问，这个值是一个异常：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/lrn-amz-sgmk-2e/img/B17705_04_9.jpg

图 4.9 – 查看异常分数

探索时间序列的其他区间，我们肯定能找到更多。谁说机器学习不有趣？
最后，我们删除端点：
```
rcf_predictor.delete_endpoint()
```

经过五个完整示例后，你现在应该对内置算法、SageMaker 工作流以及 SDK 有了熟悉。为了更深入地掌握这些主题，我建议你尝试自己的数据集，并运行 github.com/awslabs/amazon-sagemaker-examples/tree/master/introduction_to_amazon_algorithms 中的其他示例。

总结

如你所见，内置算法是快速训练和部署模型的好方法，无需编写任何机器学习代码。

在本章中，你了解了 SageMaker 工作流，并学习了如何通过 SageMaker SDK 中的一些 API 实现它，而无需担心基础设施。

你已经学习了如何处理 CSV 格式和 RecordIO 封装的 protobuf 格式数据，后者是大规模训练庞大数据集时推荐的格式。你还学会了如何使用重要的算法来构建监督学习和无监督学习模型：线性学习器（Linear Learner）、XGBoost、因式分解机（Factorization Machines）、主成分分析（PCA）和随机切割森林（Random Cut Forest）。

在下一章中，你将学习如何使用额外的内置算法来构建计算机视觉模型。

您可能感兴趣的与本文相关的镜像