亚马逊-Sagemaker-Studio-入门指南-全-

亚马逊 Sagemaker Studio 入门指南（全）

原文：annas-archive.org/md5/afbd2b4d91c08d0ea2b8e3d77eaaa2ac

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Amazon SageMaker Studio 是第一个集成开发环境（IDE）为机器学习（ML）设计，旨在整合 ML 工作流程：数据准备、特征工程、统计偏差检测、自动化机器学习（AutoML）、训练、托管、ML 可解释性、监控和 MLOps 在一个环境中。

在本书中，你将从探索 Amazon SageMaker Studio 中可用的功能开始，以分析数据、开发 ML 模型，并将模型生产化以满足你的目标。随着你的进步，你将了解这些功能如何协同工作，以解决在生产中构建 ML 模型时遇到的常见挑战。之后，你将了解如何有效地使用 SageMaker Studio 规模化和运营 ML 生命周期。

在本书结束时，你将学习有关 Amazon SageMaker Studio 的 ML 最佳实践，以及能够在 ML 开发生命周期中提高生产力，并轻松为你的 ML 用例构建和部署模型。

本书面向的对象

本书面向数据科学家和 ML 工程师，他们希望熟练掌握 Amazon SageMaker Studio，并获得实际 ML 经验来处理 ML 生命周期的每个步骤，包括构建数据以及训练和托管模型。尽管需要基本了解 ML 和数据科学，但不需要任何先前的 SageMaker Studio 或云经验。

本书涵盖的内容

第一章, 机器学习及其在云中的生命周期，描述了云计算技术如何使机器学习领域民主化，以及机器学习如何在云中部署。它介绍了本书中使用的 AWS 服务的 fundamentals。

第二章, 介绍 Amazon SageMaker Studio，涵盖了 Amazon SageMaker Studio 的概述，包括其功能和用户界面组件。你将设置一个 SageMaker Studio 域，并熟悉基本操作。

第三章, 使用 SageMaker Data Wrangler 进行数据准备，探讨了如何使用 SageMaker Data Wrangler 通过点选操作（即，无需任何编码）执行探索性数据分析以及为 ML 模型进行数据预处理。你将能够快速迭代数据转换和建模，以查看你的转换配方是否有助于提高模型性能，了解数据中是否存在对敏感群体的隐含偏差，并清楚地记录对处理数据所做的转换。

第四章, 使用 SageMaker Feature Store 构建特征库，探讨了 SageMaker Feature Store，它允许存储用于机器学习训练和推理的特征。特征库作为协作开发机器学习用例的团队的中央存储库，以避免在创建特征时重复和混淆工作。SageMaker Feature Store 使得存储和访问训练和推理数据变得更加容易和快速。

第五章, 使用 SageMaker Studio IDE 构建和训练机器学习模型，探讨了如何使构建和训练机器学习模型变得简单。不再需要在配置和管理计算基础设施时感到沮丧。SageMaker Studio 是一个为机器学习开发者设计的集成开发环境。在本章中，您将学习如何使用 SageMaker Studio IDE、笔记本和 SageMaker 管理的训练基础设施。

第六章, 使用 SageMaker Clarify 检测机器学习偏差和解释模型，介绍了在机器学习生命周期中检测和修复数据与模型中的偏差的能力，这对于创建具有社会公平性的机器学习模型至关重要。您将学习如何应用 SageMaker Clarify 来检测数据中的偏差，以及如何阅读 SageMaker Clarify 中的指标。

第七章, 在云中托管机器学习模型：最佳实践，探讨了在成功训练模型后，如果您想使模型可用于推理，SageMaker 根据您的用例提供了几个选项。您将学习如何托管用于批量推理的模型，进行在线实时推理，以及使用多模型端点以节省成本，以及针对您的推理需求的一种资源优化策略。

第八章, 使用 SageMaker JumpStart 和 Autopilot 快速启动机器学习，探讨了 SageMaker JumpStart，它为选定的用例提供完整的解决方案，作为进入 Amazon SageMaker 机器学习世界的入门套件，无需任何代码开发。SageMaker JumpStart 还为您整理了流行的预训练计算机视觉（CV）和自然语言处理（NLP）模型，以便您轻松部署或微调到您的数据集中。SageMaker Autopilot 是一个 AutoML 解决方案，它探索您的数据，代表您构建特征，并从各种算法和超参数中训练最优模型。您无需编写任何代码，因为 Autopilot 会为您完成这些工作，并返回笔记本以展示它是如何做到的。

第九章，在 SageMaker Studio 中大规模训练机器学习模型，讨论了典型的机器学习生命周期通常从原型设计开始，然后过渡到生产规模，数据量将大大增加，模型将更加复杂，实验数量呈指数增长。SageMaker Studio 使这种过渡比以前更容易。您将学习如何运行分布式训练，如何监控训练作业的计算资源和建模状态，以及如何使用 SageMaker Studio 管理训练实验。

第十章，使用 SageMaker 模型监控在生产中监控机器学习模型，探讨了数据科学家过去花费太多时间和精力维护和手动管理机器学习管道的过程，这个过程从数据处理、训练和评估开始，以模型托管和持续维护结束。SageMaker Studio 提供了旨在通过持续集成和持续交付（CI/CD）最佳实践简化此操作的功能。您将学习如何实现 SageMaker 项目、管道和模型注册，这将有助于通过 CI/CD 实现机器学习生命周期的操作化。

第十一章，使用 SageMaker 项目、管道和模型注册表实现机器学习项目的操作化，讨论了将模型投入生产进行推理并不是生命周期的终点。这只是重要话题的开始：我们如何确保模型在实际生活中按照设计和预期运行？使用 SageMaker Studio 可以轻松监控模型在生产中的表现，尤其是在模型从未见过的数据上。您将学习如何为在 SageMaker 中部署的模型设置模型监控，检测数据漂移和性能漂移，并在实时中可视化推断数据中的特征重要性和偏差。

下载示例代码文件

您可以从 GitHub 下载本书的示例代码文件：github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio。如果代码有更新，它将在 GitHub 仓库中更新。

我们还有其他来自我们丰富图书和视频目录的代码包可供下载。

https://github.com/PacktPublishing/。查看它们！

下载彩色图像

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

使用的约定

粗体：表示新术语、重要单词或屏幕上看到的单词。例如，菜单或对话框中的单词以粗体显示。以下是一个示例：“需要编目记录的两种元数据类型包括功能和技术。”

小贴士或重要注意事项

看起来像这样。

联系我们

我们欢迎读者的反馈。

一般反馈：如果您对这本书的任何方面有疑问，请在邮件主题中提及书名，并给我们发送电子邮件至 customercare@packtpub.com。

勘误表：尽管我们已经尽最大努力确保内容的准确性，但错误仍然可能发生。如果您在这本书中发现了错误，如果您能向我们报告，我们将不胜感激。请访问 www.packtpub.com/support/errata，选择您的书籍，点击勘误提交表单链接，并输入详细信息。

盗版：如果您在互联网上以任何形式发现我们作品的非法副本，如果您能向我们提供地址或网站名称，我们将不胜感激。请通过 copyright@packt.com 联系我们，并提供材料的链接。

如果您有兴趣成为作者：如果您在某个主题上具有专业知识，并且您有兴趣撰写或为书籍做出贡献，请访问 authors.packtpub.com。

评论

请留下评论。一旦您阅读并使用了这本书，为何不在您购买它的网站上留下评论呢？潜在读者可以查看并使用您的客观意见来做出购买决定，Packt 可以了解您对我们产品的看法，我们的作者也可以看到他们对书籍的反馈。谢谢！

如需了解 Packt 的更多信息，请访问 packt.com。

分享您的想法

一旦您阅读了《Amazon SageMaker Studio 入门》，我们很乐意听听您的想法！请点击此处直接进入此书的 Amazon 评论页面并分享您的反馈。

您的评论对我们和科技社区都至关重要，并将帮助我们确保我们提供高质量的内容。

第一部分 – 亚马逊 SageMaker Studio 机器学习简介

在本节中，我们将介绍机器学习（ML）、云中的机器学习生命周期以及亚马逊 SageMaker Studio。本节还包括了机器学习领域术语的水平设置，以及示例用例。

本节包括以下章节：

• 第一章, 机器学习及其在云中的生命周期

• 第二章, 介绍亚马逊 SageMaker Studio

第一章: 云中的机器学习及其生命周期

机器学习（ML）是一种存在了几十年的技术。难以相信 ML 现在在我们的日常生活中如此普遍。ML 领域成为主流也经历了一段坎坷的道路，直到最近计算机技术的重大飞跃。今天的计算机硬件更快、更小、更智能。互联网速度更快、更方便。存储更便宜、更小。现在，使用我们现在的技术，收集、存储和处理大量数据变得相当容易。我们能够创建以前无法创建的大量数据集，使用以前不可用的计算资源训练机器学习模型，并在我们生活的每个角落使用机器学习模型。

例如，媒体流媒体公司现在可以利用其网站上的标题集合和客户活动数据，在全球范围内构建机器学习推荐引擎，以实时提供最相关的内容，从而优化客户体验。标题和客户偏好及活动数据的大小，在 20 年前是无法想象的，考虑到我们中有多少人正在使用流媒体服务。

在这个规模上训练机器学习模型，使用越来越复杂的机器学习算法，需要一个强大且可扩展的解决方案。模型训练完成后，公司能够在全球范围内提供服务，数百万用户同时从网页和移动设备访问应用程序。

公司还在为每个客户细分市场或甚至为单个客户创建越来越多的模型。还有一个维度——公司正在以没有自动训练、评估、测试和部署新模型的管道就无法管理的速度推出新模型。云计算为流媒体服务提供商提供了一个完美的基础，以执行这些机器学习活动，提高客户满意度。

如果机器学习是您感兴趣的事情，或者您已经在任何形式上从事机器学习领域的工作，这本书就是您正确的选择。您将学习所有关于机器学习的内容，以及如何与我一起在书中使用实际案例和数据集构建、训练、托管和管理机器学习模型。我假设您对机器学习和云计算有很好的理解。本章的目的是设定两种技术的概念和术语水平，定义本书的核心——机器学习生命周期，并提供关于亚马逊网络服务和其核心服务的快速课程，这些将在本书中提及。

在本章中，我们将涵盖以下内容：

• 理解机器学习及其生命周期

• 在云中构建机器学习

• 探索 AWS 机器学习基础知识

• 设置 AWS 环境

技术要求

为了本章，你需要一台连接到互联网的计算机和浏览器来执行以下章节中 Amazon SageMaker 设置和代码样本的基本 AWS 账户设置。

理解机器学习及其生命周期

在其核心，机器学习是一个使用计算机算法自动发现数据集（这是一个包含具有特征的观察集合，也称为变量）中的潜在模式和趋势的过程，进行预测，获取与真实值（如果提供）的错误度量，并通过优化过程从错误中“学习”，以便下次做出预测。在过程的最后，一个机器学习模型被拟合或训练，以便它可以被用来应用其学到的知识，根据新观察的特征做出决策。这个过程的第一部分，生成模型，被称为训练，而第二部分被称为预测或推理。

基于训练过程的方式，机器学习算法主要有三种基本类型——监督学习、无监督学习和强化学习。监督学习算法被提供一组带有过去真实值的观察数据。真实值是训练监督学习算法的关键成分，因为它决定了模型如何学习和做出未来的预测——因此，名称中的“监督”一词，意味着学习是在真实值的监督下进行的。另一方面，无监督学习不需要真实值来学习如何应用预测。它仅根据观察的特征来寻找模式和关系。然而，如果存在真实值，它仍然可以帮助我们验证和理解无监督学习情况下模型的准确性。强化学习，通常缩写为RL，与前面两种相比，具有相当不同的学习范式。强化学习由一个代理与一组动作、相应的奖励和状态的环境进行交互。学习不是由真实值引导的，而是通过优化累积奖励与动作来进行的。最终训练好的模型将能够在环境中自主执行动作以实现最佳奖励。

机器学习生命周期

现在我们对机器学习有了基本的了解，我们可以更广泛地看看典型的机器学习生命周期是什么样的，如下面的图所示：

![图 1.1 – 机器学习生命周期

图 1.1 – 机器学习生命周期

问题界定

成功的机器学习生命周期中的第一步是将业务问题框架化为机器学习问题。业务问题形形色色。例如，"我们如何增加新产品的销售额？" 和 "我们如何提高装配线上的 QA 质量评估（QA）吞吐量？" 这样的业务问题通常是定性的，不是机器学习可以直接应用的问题。但是，在审视业务问题陈述时，我们应该考虑如何将其转化为机器学习问题。我们应该提出以下问题：

• "产品销售成功的关键因素是什么？"

• "哪些人最有可能购买该产品？"

• "装配线中的吞吐量瓶颈在哪里？"

• "我们如何知道一个项目是否有缺陷？一个有缺陷的项目与一个正常的项目有什么区别？"

通过提出这些问题，我们开始深入到模式识别的领域，这是一个从现有数据中识别模式的过程。有了可以形成模式识别的正确问题，我们就更接近于框架化机器学习问题。然后，我们还需要了解衡量方法成功的关键指标是什么，无论我们使用机器学习还是其他方法。例如，衡量每日产品销售额是非常直接的。我们还可以通过针对最有可能转化的受众投放广告来提高销售额。然后，我们得到以下问题：

• "我们如何衡量转化率？"

• "购买过该产品的消费者有哪些共同特征？"

更重要的是，我们需要弄清楚是否甚至有一个目标指标供我们进行预测！如果有目标，我们可以将问题框架化为一个机器学习问题，例如预测未来的销售额（监督学习和回归）、预测一个客户是否会购买某个产品（监督学习和分类），或者识别有缺陷的项目（监督学习和分类）。没有明确预测目标的问题将落入无监督学习任务中，以便将发现的数据模式应用于未来的数据点。目标动态且高度不确定的用例，如自动驾驶、机器人控制和股价预测，是强化学习的良好候选。

数据探索和工程

获取数据是成功机器学习建模之旅的第一步。一旦我们清楚地定义了业务问题和机器学习问题，并对问题的范围有一个基本了解——即，什么是指标，什么是因素——我们就可以开始收集机器学习所需的数据。数据科学家探索数据源，以找出可能支持建模的相关信息。有时，组织内部捕获和收集的数据很容易获取。有时，数据在组织外部可用，可能需要你伸出援手并请求数据共享许可。

有时，数据集可以从公共互联网和专注于为机器学习目的创建和共享标准化数据集的机构中获取，这在计算机视觉和自然语言理解用例中尤其如此。此外，数据可以通过网站和应用程序的流式传输到达。需要设置与数据库、数据湖、数据仓库和流源的联系。在训练机器学习模型之前，需要将数据集成到机器学习平台中进行处理和工程。

管理数据不规则性和异质性是机器学习生命周期的第二步。需要处理数据以消除不规则性，例如缺失值、错误的数据输入和异常值，因为许多机器学习算法都有统计假设，这些不规则性会违反假设并使建模无效（如果不合法）。例如，线性回归模型假设误差或残差是正态分布的，因此检查是否存在可能导致此类违规的异常值非常重要。如果是这样，我们必须执行必要的预处理任务来纠正它。常见的预处理方法包括但不限于删除无效条目、删除极端数据点（也称为异常值）和填充缺失值。数据还需要进行处理，以消除特征之间的异质性并将它们归一化到相同的尺度，因为某些机器学习算法对特征的尺度敏感，并可能对尺度较大的特征产生偏差。常见的方法包括最小-最大缩放和z 标准化（z 分数）。

可视化和数据分析是机器学习生命周期的第三步。数据可视化使数据科学家能够轻松地从视觉上理解数据的分布和数据的趋势。探索性数据分析（EDA）使数据科学家能够理解手头数据的统计行为，找出具有预测力的信息并将其包含在建模过程中，并消除数据中的任何冗余，例如重复条目、多重共线性和不重要的特征。

特征工程是机器学习生命周期的第四步。即使我们从各种来源收集数据，机器学习模型通常也受益于从现有特征计算出的工程化特征。例如，体质指数（BMI）是一个众所周知的工程化特征，它是通过计算一个人的身高和体重得出的，并且也是一个已确立的特征（或临床术语中的风险因素），它预测某些疾病而不是仅仅身高或体重。特征工程通常需要在该领域有丰富的经验并进行实验，以找出哪些配方能为建模增加预测能力。

建模和评估

对于数据科学家来说，机器学习建模是生命周期中最激动人心的部分（我认为是这样；希望你也同意）。你已经用机器学习的语言表述了问题。你已经收集、处理了数据，并观察到了那些能给你足够提示以构建机器学习模型的基本趋势。现在，是时候为数据集构建你的第一个模型了，但是等等——我们使用什么模型、什么算法以及什么指标来评估性能呢？嗯，这就是建模和评估的核心。

目标是探索并从所有可能的算法、特征集和超参数中找到一个令人满意的机器学习模型，并使用客观指标。这绝对不是一项容易的任务，需要丰富的经验。根据问题类型（无论是分类、回归还是强化学习）、数据类型（如表格、文本或图像数据）、数据分布（是否存在类别不平衡或异常值？）以及领域（医疗、金融或工业），你可以将算法的选择缩小到几个。对于这些算法中的每一个，都有控制算法在提供的数据上的行为和性能的超参数。还需要定义一个符合业务要求的客观指标和阈值，使用该指标来指导你找到最佳模型。你可能会盲目地为你项目选择一两个算法-超参数组合，但你可能无法在仅仅一两次尝试中就达到最优解。数据科学家尝试数百甚至数千种组合是很常见的。这是如何实现的呢？

这就是为什么建立一个简化的模型训练和评估流程在过程中是一个如此关键的步骤。一旦模型训练和评估自动化，你就可以简单地启动一个过程，帮助你自动迭代算法和超参数之间的实验，并比较指标性能以找到最优解。这个过程被称为超参数调整或超参数优化。如果多个算法是调整的对象，它也可以被称为多算法超参数调整。

生产 - 预测、监控和再训练

机器学习模型需要投入使用才能对业务产生影响。然而，其生产过程与典型软件应用的生产过程不同。与其他软件应用不同，业务逻辑可以在生产前预先编写并彻底测试边缘情况，而一旦模型被训练和评估，并不能保证其在生产环境中的表现与测试环境中的表现相同。这是因为机器学习模型使用概率、统计和模糊逻辑来推断每个输入数据点的结果，而测试，即模型评估，通常是在对生产数据没有真正先验知识的情况下进行的。数据科学家在生产前能做的最好的事情是从一个紧密代表现实世界数据的样本中创建训练数据，并使用样本外策略评估模型，以获得模型在未见数据上表现的无偏看法。在生产中，模型完全看不到输入数据；如何评估实时模型性能，以及如何根据评估采取行动，是生产化机器学习模型的关键话题。

模型性能可以通过两种方法进行监控。一种更直接的方法是捕获未见数据的真实情况，并将预测与真实情况进行比较。第二种方法是使用数据的漂移作为代理来确定模型是否将以预期的方式表现。在某些用例中，第一种方法不可行，因为真实结果（真实情况）可能落后于事件很长时间。例如，在疾病预测用例中，机器学习建模的目的是帮助医疗保健提供者在当前健康指标下找到未来三个月内可能的结果，在这种情况下，不可能在不到三个月或更晚的时候收集到真实情况，这取决于疾病的发作时间。因此，仅在生产后修复模型是不切实际的，如果证明其无效。

第二种方法基于这样一个前提：机器学习模型从训练数据中统计和概率性地学习，当提供具有不同统计特征的新数据集时，其行为可能会有所不同。当数据不是来自相同的统计分布时，模型会返回无意义的输出。因此，通过检测数据的漂移，它提供了对模型将如何表现的一个更实时的估计。以疾病预测用例为例：当关于 30 多岁患者群体的数据被发送到一个在平均年龄为 65 岁的数据上训练的机器学习模型进行预测时，该模型很可能对这些新患者一无所知。因此，我们需要采取行动。

重新训练和更新模型确保它在未来的数据中保持性能。能够捕捉到真实情况和检测数据漂移有助于在正确的时间制定重新训练策略。漂移的数据和真实情况是重新训练过程中的重要输入，因为它们将帮助模型覆盖更广泛的统计分布。

现在我们已经清楚地了解了机器学习开发的基本用途和生命周期，让我们进一步探讨它如何与云协同工作。

在云端构建机器学习

云计算是一种技术，它提供按需 IT 资源，可以根据需要随时增长和缩小。不再需要购买和维护计算机服务器或数据中心。这就像您家里的公用事业一样，比如水，当你打开水龙头时它就在那里。如果你完全打开，你会得到高压水流。如果你调低，你会节约用水。如果你不再需要它，你可以完全关闭。使用这种模式，开发者和团队可以从按需云计算中获得以下好处：

• 敏捷性：根据需要快速启动资源。快速开发并推出新应用，尝试新想法，快速失败而无需承担风险。

• 弹性：根据需要扩展您的资源。云计算消除了“无差别的繁重劳动”——堆叠额外的服务器和为未来规划容量。这些都是不能帮助解决您核心业务问题的东西。

• 全球可用性：只需点击一下按钮，您就可以启动位于您客户/用户附近的最接近的资源，而无需重新安置您的物理计算资源。

这对机器学习领域有何影响？ 随着计算资源获取变得更加容易，信息交换变得更加频繁。当这种情况发生时，会产生和存储更多的数据。更多的数据意味着有更多机会训练更准确的机器学习模型。云计算提供的灵活性、弹性和可扩展性加速了机器学习模型从几周到几个月的开发和应用周期，缩短到更短的周期，这样开发者现在可以比以往任何时候都更快地生成和改进机器学习模型。开发者不再受限于他们可用的物理计算资源。有了更好的机器学习模型，企业可以做出更好的决策，并为顾客提供更好的产品体验。

在本书中，我们将使用亚马逊网络服务（Amazon Web Services）作为云计算提供商，它是亚马逊 SageMaker Studio 的提供者。

探索 AWS 机器学习基础

亚马逊网络服务（AWS）为各种开发者提供云计算资源，以创建他们业务的应用程序和解决方案。AWS 在一个安全的环境中并以可扩展的方式管理技术和基础设施，从而从开发者手中移除了基础设施管理的繁重工作。AWS 提供了广泛的服务，包括机器学习、人工智能、物联网、分析和应用程序开发工具。这些服务建立在以下关键领域之上——计算、存储、数据库和安全。在我们开始使用亚马逊 SageMaker Studio 的旅程之前，这是 AWS 提供的机器学习服务之一，了解在亚马逊 SageMaker Studio 开发机器学习项目时常用的核心服务非常重要。

计算

对于云中的机器学习，开发者需要在生命周期的各个方面都需要计算资源。亚马逊弹性计算云（Amazon EC2）是开发者处理、训练和托管机器学习模型的最基本的云计算环境。Amazon EC2 提供了多种计算实例类型，适用于各种目的，如计算密集型工作的计算优化实例、具有大内存占用应用程序的内存优化实例，以及用于深度学习训练的图形处理单元（GPU）加速实例。

亚马逊 SageMaker 也为机器学习开发者提供按需计算资源，以便运行处理、训练和模型托管。亚马逊 SageMaker 的机器学习实例建立在亚马逊 EC2 实例之上，并为实例配备了完全管理的、优化的流行机器学习框架版本，如 TensorFlow、PyTorch、MXNet 和 scikit-learn，这些框架针对亚马逊 EC2 计算实例进行了优化。开发者无需管理机器学习实例的配置和修补，因此可以专注于机器学习生命周期。

存储

在进行机器学习项目时，开发者需要能够访问文件、存储代码和存储工件。可靠的存储对于机器学习项目至关重要。AWS 为机器学习开发提供了多种存储选项。亚马逊简单存储服务（Amazon S3）和亚马逊弹性文件系统（Amazon EFS）是亚马逊 SageMaker Studio 中开发机器学习项目最相关的两种。

Amazon S3 是一种对象存储服务，允许开发者以高安全性、可用性和可扩展性存储任何数量的数据。机器学习开发者可以在 Amazon S3 上存储结构化和非结构化数据，以及带有版本控制的机器学习模型。Amazon S3 还可用于构建用于分析的数据库湖和存储备份和归档。

Amazon EFS 提供了一种完全托管、无服务器的文件系统，允许开发者在文件系统中存储和共享文件，无需进行任何存储配置，因为当您添加或删除文件时，文件系统会自动增加或减少其容量。它通常用于高性能集群（HPC）设置以及需要跨线程、处理任务、计算实例和用户进行并行或同时数据访问且具有高吞吐量的应用程序。由于 Amazon SageMaker Studio 集成了 Amazon EFS 文件系统，因此 Amazon SageMaker Studio 上的每个用户都有一个用于存储和访问数据、代码和笔记本的本地目录。

数据库和数据分析

除了存储选项，数据作为文件或对象保存之外，AWS 用户可以使用数据库服务如Amazon 关系数据库服务（Amazon RDS）和Amazon DynamoDB在数据点级别存储和访问数据。AWS 分析服务如AWS Glue和Amazon Athena在机器学习生命周期的早期阶段提供了存储、查询和数据处理的必要功能。

对于机器学习项目，关系数据库是建模的常见数据来源。Amazon RDS 是云中的一种成本效益高且可扩展的关系数据库服务。它提供包括开源的 PostgreSQL、MySQL 和 MariaDB 以及 Oracle 和 SQL Server 商业数据库在内的六种数据库引擎。使用 Amazon RDS 可以简化基础设施的配置和管理。

另一个流行的数据库是 NoSQL，它使用键值对作为数据结构。与关系数据库不同，NoSQL 数据库不需要对表有严格的模式要求。用户可以为每一行数据输入具有灵活模式的资料，而无需更改模式。Amazon DynamoDB 是一个完全托管、无服务器且高度可扩展的键值和文档数据库。

AWS Glue 是一种数据集成服务，具有帮助开发者从源数据中发现和转换数据以进行分析和机器学习的几个功能。AWS Glue 数据目录提供了一个持久元数据存储，作为所有数据源的中心存储库，例如 Amazon S3、Amazon RDS 和 Amazon DynamoDB 中的表。开发者可以在一个地方查看所有他们的表和元数据，如模式和时间更新——AWS Glue 数据目录。AWS Glue 的 ETL 服务有助于在 AWS Glue 数据目录中发现和编目数据后，立即简化提取、转换和加载步骤。

Amazon Athena 是一种分析服务，为开发者提供了一种交互式和无服务器的查询体验。作为一个无服务器服务，开发者不需要考虑底层的基础设施，而是专注于他们的数据查询。您可以通过一个模式定义轻松地将 Amazon Athena 指向 Amazon S3 中的数据，以开始查询。Amazon Athena 与 AWS Glue 数据目录无缝集成，允许您快速轻松地查询来自所有来源和服务的您的数据。Amazon Athena 还与 Amazon SageMaker Studio 的多个方面高度集成，我们将在本书的后续章节中详细介绍。

安全性

在 AWS 上开发应用程序、访问数据和训练 ML 模型时，安全性是首要任务。安全性的访问和身份控制方面由 AWS 身份和访问管理（IAM）服务管理。AWS IAM 可以对服务、云资源、身份验证和授权进行细粒度管理。

IAM 的关键概念包括 IAM 用户、组、角色和策略。每个登录 AWS 的人都会假定一个 IAM 用户。每个 IAM 用户都有一系列 IAM 策略附加，这些策略控制着 AWS 中该 IAM 用户可以命令和访问的资源及操作。IAM 用户还可以从具有相似责任的 IAM 组继承 IAM 策略。IAM 角色与 IAM 用户类似，因为它有一组权限来访问资源和执行操作。IAM 角色与 IAM 用户的不同之处在于，角色可以被用户、应用程序或服务假定。例如，您可以为云中的应用程序创建并分配一个 AWS 服务角色，以允许应用程序访问哪些服务和资源。拥有访问应用程序权限的 IAM 用户可以安全地执行应用程序，无需担心应用程序会访问未经授权的资源。更多信息请参阅：docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html。

设置 AWS 环境

让我们设置一个 AWS 账户，开始我们的云计算之旅。如果您已经有了 AWS 账户，您可以跳过这一部分，继续下一章。

请访问 portal.aws.amazon.com/billing/signup 并按照说明进行操作以注册账户。您将接到电话，作为流程的一部分，您需要在电话键盘上输入验证码。

当您首次创建新的 AWS 账户并使用您的电子邮件和密码登录时，您将以账户 root 用户登录。然而，在以 root 用户登录的情况下，最好创建一个具有AdministratorAccess策略的新 IAM 用户，然后迅速注销并再次以您刚刚创建的 IAM 用户登录。root 用户凭据应仅用于执行有限的账户和服务管理任务，不应用于开发您的云应用程序。您应安全地存储 root 用户凭据，并将其锁起来，防止其他人员访问。

下面是创建 IAM 用户的步骤：

1. 前往 IAM 控制台，在左侧面板中选择用户，然后点击添加用户按钮：

![图 1.2 – 在 IAM 控制台中添加 IAM 用户

图 1.2 – 在 IAM 控制台中添加 IAM 用户

1. 接下来，在用户名中输入一个名称，并勾选程序访问和AWS 管理控制台访问的复选框。对于密码字段，您可以保留默认选项。点击下一步：权限按钮继续：

![图 1.3 – 为 IAM 用户创建用户名和密码

图 1.3 – 为 IAM 用户创建用户名和密码

1. 在下一页，选择设置权限下的将用户添加到组。在新的账户中，您没有任何组。您应该点击创建组。

2. 在弹出对话框中，在策略列表中的AdministratorAccess下输入Administrator，然后点击创建组按钮：

![图 1.4 – 使用管理员访问权限创建 IAM 组

图 1.4 – 使用管理员访问权限创建 IAM 组

1. 对话框将关闭。确保已选择新的管理员，并点击下一步：标签。您可以可选地为 IAM 用户添加键值对标签。点击下一步：审查以审查配置。当一切正确时，点击创建用户。

您将看到以下信息。请记下登录 URL 以便于控制台访问，访问密钥 ID和秘密访问密钥用于程序访问，以及一次性密码。您还可以通过点击下载.csv按钮将凭据作为 CSV 文件下载：

![图 1.5 – 创建一个新的 IAM 用户

图 1.5 – 创建一个新的 IAM 用户

1. IAM 用户创建后，您可以使用登录 URL 和 IAM 用户登录您的 AWS 账户。当您首次登录时，您需要提供自动生成的密码，然后设置一个新的密码。现在，您应该在右上角注意到您是以新创建的 IAM 用户而不是 root 用户登录的：

图 1.6 – 确认您新创建的凭据

如果你刚开始接触 AWS，不必担心尝试 AWS 的成本。AWS 提供了一个基于服务消耗和/或 12 个月内的免费层，超过 100 个服务。本书中我们将使用的服务，如 S3 存储桶和 Amazon SageMaker，都提供了免费层，让你学习技能而无需花费大量资金。以下表格是对本书将要涵盖的服务免费层的总结：

图 1.7 – AWS 中的显著免费试用优惠

让我们通过回顾本章所涵盖的内容来结束本章。

摘要

在本章中，我们描述了机器学习的概念、机器学习生命周期中的步骤，以及如何用机器学习思维来处理商业问题。我们还讨论了云计算的基础知识、它在机器学习开发中的作用以及 Amazon Web Services 上的核心服务。最后，我们创建了一个 AWS 账户，并设置了一个用户，以便我们在本书的愉快旅程中使用。

在下一章中，我们将从高层次的角度学习 Amazon SageMaker Studio 及其组件。我们将看到每个组件是如何映射到本章所学的机器学习生命周期，并一起设置我们的 Amazon SageMaker Studio 环境。

第二章：介绍 Amazon SageMaker Studio

正如我们刚刚在第一章，“云中的机器学习及其生命周期”中学习的，机器学习生命周期是复杂且迭代的。尽管大多数事情都是通过编码完成的，但步骤可能相当手动。对于机器学习项目来说，拥有合适的工具对于你在云中成功交付机器学习模型至关重要。通过本章，你将处于正确的位置！Amazon SageMaker Studio 是一个专为机器学习设计的集成开发环境（IDE），它提供了覆盖端到端机器学习生命周期的功能，使开发人员和数据科学家在 AWS 云中的工作变得容易。

在本章中，我们将涵盖以下内容：

• 介绍 SageMaker Studio 及其组件

• 设置 SageMaker Studio

• 漫步 SageMaker Studio 用户界面

• 揭秘 SageMaker Studio 笔记本、实例和内核

• 使用 SageMaker Python SDK

技术要求

对于本章，您需要一个 AWS 账户。如果您还没有，请回顾第一章，“云中的机器学习及其生命周期”中的设置 AWS 环境部分。

介绍 SageMaker Studio 及其组件

Amazon SageMaker 是 AWS 提供的机器学习服务，具有针对我们在第一章，“云中的机器学习及其生命周期”中讨论的机器学习生命周期每个阶段的专用功能。Amazon SageMaker Studio 是一个专为使用 Amazon SageMaker 进行端到端机器学习开发设计的机器学习 IDE。您可以使用 SageMaker Studio IDE 或使用 SageMaker Python SDK 访问 Amazon SageMaker 功能，正如我们将在使用 SageMaker Python SDK部分讨论的那样。以下图表提供了一个概述：

![图 2.1 – Amazon SageMaker Studio 概览 – 四个支柱代表机器学习生命周期的四个阶段]

![img/B17447_02_01.jpg]

图 2.1 – Amazon SageMaker Studio 概览 – 四个支柱代表机器学习生命周期的四个阶段

本图表突出了书中涵盖的 SageMaker 组件。让我们首先从本章对每个组件在机器学习生命周期各个阶段的概述开始。然后，我将提供指向后续章节的指南。

准备

Amazon SageMaker Studio 帮助数据科学家和开发者快速构建高质量的机器学习数据集。您可以使用以下功能来探索、处理、转换数据，并将处理后的数据或机器学习特征存储在中央存储库中。

SageMaker 数据整理器

Amazon SageMaker Data Wrangler 帮助开发者以快速、简便和可重复的方式探索和构建机器学习（ML）的数据集。SageMaker Data Wrangler 将数据准备工作流程——从各种云存储和数据仓库导入、聚合多个表、理解数据偏差和目标泄露，以及使用可视化探索数据模式——集成在一个易于使用的图形界面中，您只需简单地点击即可创建可重复和可移植的数据配方。易于使用的图形界面仅限于 SageMaker Studio。SageMaker Data Wrangler 拥有超过 300 个内置数据转换，因此您无需在机器学习的典型数据处理步骤中重新发明轮子。除了内置转换外，SageMaker Data Wrangler 还支持使用 Python、SQL 和 PySpark 编写的自定义转换，以丰富您的数据工程步骤。我们将在 第三章 中深入了解 SageMaker Data Wrangler，即 使用 SageMaker Data Wrangler 进行数据准备。

SageMaker Clarify

Amazon SageMaker Clarify 帮助开发者发现训练数据中的潜在偏差，并从模型预测中解释特征重要性。数据偏差是指由于抽样错误或其他复杂原因导致的不同群体和类别（如年龄和教育水平）在训练数据中的不平衡。数据偏差通常直到训练模型对某个群体做出错误或不公平的预测时才会被忽视。众所周知，模型将学习数据中存在的内容，包括任何偏差，并将其复制到其推断中。能够早期发现数据中的固有偏差并采取行动解决它们比以往任何时候都更加重要。SageMaker Clarify 计算各种指标来衡量数据中的偏差，这样您就不必成为机器学习偏差科学的专家。SageMaker Clarify 与 Amazon SageMaker Data Wrangler 集成，以便您可以在准备阶段检测偏差。SageMaker Clarify 还与 Amazon SageMaker Experiments 和 Amazon SageMaker Model Monitor 集成，以便您可以在训练模型和推理数据中识别偏差和特征重要性。我们将在 第六章 中了解更多关于 SageMaker Clarify 的信息，即 使用 SageMaker Clarify 检测机器学习偏差和解释模型。

SageMaker Processing

Amazon SageMaker Processing 是一个功能，它可以在 SageMaker 的完全托管计算实例中运行您的脚本和容器，而不是您的有限本地计算资源。它旨在使数据处理和模型评估变得简单且可扩展。它具有灵活性，因此开发人员可以在 ML 生命周期的任何时间运行任何代码。SageMaker Processing 还与几个 SageMaker 功能集成，作为计算骨干。SageMaker Data Wrangler 使用 SageMaker Processing 来执行您的 SageMaker Data Wrangler 数据配方，并将处理后的特征保存到存储中。SageMaker Clarify 使用 SageMaker Processing 来计算偏差指标和特征重要性。将在本章后面的 部署 部分讨论的 SageMaker Model Monitor 使用 SageMaker Processing 来计算数据漂移。将在接下来的 构建 部分讨论的 SageMaker Autopilot 使用 SageMaker Processing 进行数据探索和特征工程。

SageMaker 特征存储

Amazon SageMaker Feature Store 是一个完全托管的 ML 特征存储库，允许 ML 开发人员存储、更新、查询和与其他 ML 开发人员共享 ML 特征，并具有治理功能。在许多团队协作进行特征工程但继续创建他们自己的模型组织中，拥有一个中央特征存储库作为特征的单一来源，可以加快模型开发的速度，因为现在特征可以在团队之间以及用于训练和推理的应用程序中共享和重用。它减少了团队的特征开发时间和努力浪费。SageMaker Feature Store 提供了 在线 和 离线特征存储，分别用于实时、低延迟的 ML 推理和查询用于模型训练的批量数据。SageMaker Feature Store 还具有版本控制和时间旅行功能，允许开发人员重用特征并审计过去模型训练和推理。我们将在 第四章**，使用 SageMaker Feature Store 构建特征存储库 中进一步探讨 SageMaker Feature Store。

构建

作为 ML IDE 的 Amazon SageMaker Studio 具有许多功能和功能，可以帮助您根据您的用例和项目复杂度构建 ML 模型。听说过 ML 算法但不确定如何实现它？Amazon SageMaker Studio 提供了 低到无代码选项 – 自动 ML（autoML）、预构建的 ML 解决方案和内置训练算法 – 通过简单地插入您的数据，帮助您构建复杂的 ML 模型和解决方案。SageMaker Studio 笔记本重新发明了您使用 Jupyter 笔记本开发 ML 模型的方式。

SageMaker 自动驾驶

Amazon SageMaker Autopilot 自动探索、转换数据，并为您输入的数据集自动训练和调整机器学习模型。您只需选择数据集位置和目标，SageMaker Autopilot 就可以通过简单易用的图形界面进行学习和预测。然后，它就会开始工作。SageMaker Autopilot 提供了对模型构建过程的全面控制和可见性。同时，还提供了带有代码和探索性数据分析的 Jupyter 笔记本，以便您了解 SageMaker Autopilot 在底层是如何工作的。有了可用的代码，您还可以改进过程中的任何步骤，并重新运行作业以获得更好的结果。当模型训练完成后，SageMaker Studio 用户界面使得浏览和选择最佳模型变得简单。您可以在 SageMaker Studio 中查看排行榜，比较所选机器学习算法和其他超参数之间的性能，并只需点击几个按钮即可部署最佳模型。我们将在第八章，“使用 SageMaker JumpStart 和 Autopilot 快速启动机器学习”中继续探索 SageMaker Autopilot。

SageMaker JumpStart

Amazon SageMaker JumpStart 通过提供针对行业中最常见用例精心构建的解决方案集合，以及超过 150 个流行的开源深度学习模型库，用于计算机视觉和自然语言处理用例，使得开始使用机器学习变得简单。SageMaker JumpStart 中的解决方案由一个端到端系统的参考架构组成，不仅限于机器学习建模，还可以部署到您的 AWS 账户。您只需在 SageMaker Studio IDE 内部浏览目录，找到合适的解决方案，一键部署，就可以在云中看到系统如何作为一个生产系统协同工作。至于 SageMaker JumpStart 的机器学习模型库，您也可以轻松地从目录中选择满足您用例的模型，一键部署以对您的数据进行推理或在您的应用程序中执行。您还可以使用自己的数据集微调模型，SageMaker JumpStart 完全管理训练过程，无需任何编码。我们将在第八章，“使用 SageMaker JumpStart 和 Autopilot 快速启动机器学习”中了解更多关于如何使用 SageMaker JumpStart 的信息。

SageMaker Studio 笔记本

在构建机器学习模型的话题上，开发者们通常会在 Jupyter 笔记本中编写代码，因为它的简洁性和可读性，它能捕捉代码。Amazon SageMaker Studio 界面建立在 JupyterLab 之上，并集成了许多旨在增强用户体验的额外功能。与 JupyterLab 中的常规笔记本相比，SageMaker Studio 笔记本提供了一种弹性且可扩展的方式来编写代码和构建机器学习模型。对于每个笔记本，开发者不仅可以选择运行笔记本的笔记本内核，还可以选择支持笔记本的计算实例。因此，对于数据探索笔记本，你可以为处理适量数据而配置一个具有 2 个 vCPU 和 4 GiB RAM 的实例进行绘图和数据处理。如果你需要加载更多数据或需要 GPU 进行快速实验，你可以创建一个新的笔记本并使用不同的计算实例，或者切换到现有笔记本上的不同实例。你可以在 https://aws.amazon.com/sagemaker/pricing/的Studio 笔记本选项卡中找到支持的 SageMaker 实例列表。我们将在本章后面的揭秘 SageMaker Studio 笔记本、实例和内核部分，以及第六章，使用 SageMaker Clarify 检测机器学习偏差和解释模型中，更多地讨论 SageMaker Studio 笔记本背后的基础设施。

训练算法

构建机器学习模型并不意味着你需要编写大量的代码。Amazon SageMaker 提供了 17 种可扩展、基础设施优化的内置算法，用于监督学习和无监督学习问题类型，以及表格、计算机视觉和自然语言处理（NLP）用例。内置算法旨在与 Amazon SageMaker 的完全托管计算一起使用。使用内置算法进行训练时，你将算法和超参数指向 S3 存储桶上的数据集，SageMaker 在幕后提供训练实例，将你的数据和算法作为 Docker 容器带到训练实例上，并执行训练。通过可扩展和基础设施优化，我们指的是这些算法背后的代码库针对 AWS 计算基础设施进行了优化，并且能够使用多个实例进行分布式训练。内置算法的最好之处在于，你不需要编写大量的代码。我们将在第五章**，使用 SageMaker Studio IDE 构建和训练机器学习模型中了解更多关于内置算法以及如何使用它们训练模型的信息。

训练和调整

训练和调整机器学习模型可能消耗数据科学家最多的时间和精力。为了帮助数据科学家专注于建模而不是基础设施，拥有一个完全托管、可靠且可扩展的计算环境对他们来说至关重要，这样他们才能发挥最佳水平。Amazon SageMaker Studio 通过以下功能使机器学习训练变得简单且可扩展。

管理训练

SageMaker 管理的训练使机器学习开发者能够从任何地方访问按需计算资源，并使模型训练成为一种几乎无服务器的体验。您可以使用来自广泛的 SageMaker ML 实例的最佳计算资源启动模型训练作业。您可以在aws.amazon.com/sagemaker/pricing/的训练选项卡下找到训练实例列表。对于需要强大 GPU 实例的深度学习模型，您可以轻松指定配备 GPU 设备（s）的加速计算实例。如果您手头有一个使用 CPU 而不是 GPU 的线性回归模型，您可以根据 CPU 和内存需求选择标准或计算优化实例。作为一个 SageMaker 管理的功能，您根本不需要进行服务器配置和管理。您提交一个训练作业，SageMaker 将处理服务器配置，并在训练作业完成后关闭。监控训练作业非常简单，因为训练指标和日志被推送到Amazon CloudWatch。这种体验使您能够专注于模型构建和训练，而不是基础设施。我们将在第五章**，使用 SageMaker Studio IDE 构建和训练 ML 模型中了解更多关于 SageMaker 管理的训练和用 TensorFlow 和 PyTorch 等流行 ML 框架训练 ML 模型的示例。SageMaker 管理的训练还支持 spot 实例，这样您可以在按需实例上节省高达 90%的费用。我们将在第九章**，在 SageMaker Studio 中大规模训练 ML 模型*中了解更多关于 SageMaker 管理的 spot 训练。

分布式训练库

随着深度学习模型变得越来越大并需要更多数据，训练大型神经网络推动了将 GPU 需求扩展到单个计算实例之外的需求。您需要找到一种方法将训练数据和大型神经网络模型分布到多个实例上。Amazon SageMaker 的分布式训练库使您能够以分布式方式开发您的机器学习训练代码。SageMaker 分布式训练库有两种扩展技术——数据并行和模型并行。数据并行将大型数据集分布到实例上以并行训练。模型并行将太大而无法适应单个 GPU 的模型分割成多个 GPU 上的多个部分以进行训练。SageMaker 的分布式训练库还优化了分布框架和分区算法，以便在 SageMaker 的 GPU 实例上快速训练，实现接近线性的扩展效率。通过在您的训练代码基础上添加几行代码，您可以将模型训练转变为分布式训练，以有效地利用多个实例上的多个 GPU 设备。我们将在第九章，“在 SageMaker Studio 中大规模训练机器学习模型”中通过示例深入了解分布式训练库的工作方式。

SageMaker Debugger

在模型训练工作中，了解训练过程中是否存在问题以及您的训练代码如何利用计算资源至关重要。这些反馈信息使您能够调整网络架构、更改超参数以及修改其他参数，以便您能够训练出更好的模型，避免在浪费更多时间和资源的情况下停止训练工作。Amazon SageMaker Debugger使优化机器学习模型和训练实例利用率变得简单。SageMaker Debugger 旨在实时捕获训练指标和计算资源利用率，并在出现问题时报告可操作的见解和问题。SageMaker Debugger 在 SageMaker Studio 中创建了一个交互式仪表板，您可以在训练过程中实时可视化。这对于训练复杂的神经网络模型尤其有帮助。当您在 SageMaker Studio 中大规模训练模型时，我们将在第九章，“在 SageMaker Studio 中大规模训练机器学习模型”中进一步讨论并展示如何使用 SageMaker Debugger。

SageMaker Experiments

Amazon SageMaker Experiments 是一个功能，可以帮助您在机器学习生命周期中组织和跟踪您的作业。当您开始一个机器学习项目时，您处理数据，应用带有参数的转换，并从各种算法和超参数中训练机器学习模型。您将意识到当试验和实验的数量迅速增长并变得难以管理时。开发者可以使用 SageMaker Experiments Python SDK 设置跟踪器来跟踪数据源、处理步骤和参数。SageMaker Studio IDE 使得搜索实验和试验、比较参数和模型性能以及创建图表以可视化进度变得容易。我们将在第五章**，使用 SageMaker Studio IDE 构建和训练机器学习模型中更深入地探讨 SageMaker Experiments。

部署

一个机器学习模型被创建出来用于服务和进行预测。部署机器学习模型是利用模型的第一步。如何可靠、大规模且成本效益地提供服务以进行推理，同时为您的机器学习应用创建反馈循环，这是机器学习生命周期中最重要方面之一，正如我们所学，通常 90%或更多的机器学习成本都花在为推理托管模型上。

管理部署

SageMaker 管理的模型部署消除了管理、配置和扩展模型推理计算实例的繁重工作。机器学习模型可以在 SageMaker 上进行实时推理和批量推理。如果机器学习推理是在线应用的一部分，通常需要实时推理。部署的模型还预期以低延迟的方式返回推理结果。只需几行代码，Amazon SageMaker 模型托管功能就将您的模型部署到完全管理的 ML 实例（s）作为端点，以实现低延迟的实时推理。您还可以设置端点的自动扩展，以便当模型流量增加时，SageMaker 将自动启动更多实例来处理额外的负载，以免压倒现有实例。

如果您的机器学习项目需要您为每个地理区域创建多个模型以获得更高的准确性，那么SageMaker 的多模型端点是您部署模型的经济有效选择。您不需要在 50 个端点上托管 50 个模型，当您知道某些州的流量与其他州相比会更稀疏时，您只需将 50 个模型合并为 1 个多模型端点，以充分利用端点的计算能力并降低托管成本。

对于批量推理，SageMaker 批量转换是一种经济有效且可扩展的方法，可以对大量数据集中的模型进行批量推理。SageMaker 批量转换高效地处理数据摄入，这样您就不必担心数据量会压倒计算实例。

模型部署和托管是一个大主题，我们将在第七章“在云中托管机器学习模型的最佳实践”中进一步讨论。

SageMaker Model Monitor

如第一章中所述，“机器学习及其在云中的生命周期”，关闭机器学习反馈循环是一个确保模型质量并允许开发者在为时已晚之前采取行动的步骤。Amazon SageMaker Model Monitor功能通过设置数据捕获、计算输入数据的统计信息作为基线，并按计划监控 SageMaker 上托管的真实端点的数据漂移来关闭反馈循环。SageMaker Model Monitor 使用一系列统计和指标来确定新传入的数据是否符合基线训练数据的统计和结构。您还可以定义自己的指标并在 SageMaker Model Monitor 中使用它们。一旦设置了端点的模型监控，您就可以在 SageMaker Studio IDE 中的仪表板上可视化数据漂移和任何数据问题随时间的变化。您还可以使用其他 AWS 服务设置警报和触发器，以便根据数据漂移或模型性能漂移采取行动。我们将在第十章“使用 SageMaker Model Monitor 在生产中监控机器学习模型”中了解更多内容，并展示如何设置 SageMaker 模型监控。

MLOps

数据科学家过去常常花费大量时间和精力维护和手动管理机器学习（ML）管道，这个过程从数据处理开始，经过模型训练和评估，最终以模型托管和持续维护结束。SageMaker Studio 提供了一些功能，旨在通过持续集成（CI）和持续交付（CD）作为最佳实践来简化这一操作。

SageMaker Pipelines

Amazon SageMaker Pipelines是一个编排层，允许您为机器学习生命周期构建可以在生产系统中自动化的工作流程。您可以在一个管道中自动化包括数据处理、模型训练、调优、评估和部署在内的步骤。您可以将业务条件和逻辑应用到管道中，以维护模型的质量。SageMaker Pipelines 为模型创建了一个审计跟踪，因为它将管道中每个步骤的信息保存在一个地方。SageMaker Pipelines 中的机器学习管道可以随时执行，按计划执行或在响应触发事件时执行。我们将在第十一章“使用 SageMaker 项目、管道和模型注册表实现机器学习项目的运营”中讨论并运行 SageMaker Pipelines 的示例。

SageMaker 项目和模型注册表

Amazon SageMaker 项目是一个功能，它帮助您将所有机器学习工件集中在一个地方，并使用 CI/CD 最佳实践来确保生产中的模型具有可重复性、可审计性和治理。

SageMaker 项目将 ML 代码库、管道、实验、模型注册和已部署端点收集到一个单一的视图中。SageMaker 为您提供了 MLOps 模板，以便您在 AWS 中轻松开始使用 MLOps。您可以选择内置模板或根据您的用例创建自己的模板，部署模板，并开始填写您的 ML 工作流程，以使您的 ML 工作流程具备 CI/CD 最佳实践。以下包括以下内容：

• 版本控制的代码仓库

• 自动化模型训练的 ML 管道

• 验证代码提交是否工作的代码构建流程

• 模型部署质量控制门和版本控制的模型注册

• 自动化模型部署流程

我们将在第十一章中介绍功能和 MLOps 最佳实践，使用 SageMaker Projects、Pipelines 和模型注册实现 ML 项目的运营化。

现在我们已经简要介绍了 SageMaker Studio 的许多组件，让我们准备好您的 AWS 账户，并学习如何设置 SageMaker Studio。

设置 SageMaker Studio

在核心功能准备就绪后，让我们开始使用 Amazon SageMaker Studio。请使用您的 IAM 用户登录到您的 AWS 账户，并从服务下拉菜单转到 Amazon SageMaker 控制台页面。您应该会看到图 2.2所示的页面：

图 2.2 – Amazon SageMaker 控制台页面

点击SageMaker Studio按钮。

设置域名

因为这是我们第一次使用 Amazon SageMaker Studio，我们需要设置一个 SageMaker 域名和用户配置文件。有快速入门设置和标准设置 – 您应该使用哪一个？嗯，这取决于您的需求。使用快速入门完成本书中的所有练习以及您的大多数个人项目是足够的。另一方面，标准设置提供了额外的选项，以自定义您的计算环境以满足企业中常见的特定安全要求，如网络和认证方法。

使用标准设置，您可以配置以下内容：

• 认证方法：单点登录（SSO）或AWS 身份和访问管理（IAM）。SSO 是企业团队中流行的认证方法，允许您使用单一登录凭证从任何位置登录到门户中的软件和云资源。在这种情况下，您不需要访问 AWS 控制台。然而，它要求您首先设置一个 SSO 账户。IAM 方法允许您更快、更简单地设置域名。这也是快速入门设置中使用的该方法。您需要首先使用 IAM 角色登录 AWS 控制台，以便访问 Studio。

• 权限：一个默认执行角色，定义了诸如您允许访问哪些 S3 存储桶以及您可以在 SageMaker Studio 中执行哪些操作等权限。请注意，每个添加到 SageMaker Studio 域的新用户都可以继承此默认执行角色，或者可以拥有具有不同权限的另一个执行角色。

• 笔记本共享配置：当涉及到协作时，笔记本共享是一个关键特性。如果您想加密可共享的笔记本并具有共享单元格输出的能力，可以配置笔记本共享元数据在 S3 上的存储位置，或者您可以选择禁用笔记本共享。

• SageMaker 项目和 JumpStart：您是否希望为账户和/或用户启用 SageMaker 项目模板和 JumpStart。

• 网络和存储：作为云资源，SageMaker Studio 可以在 虚拟私有云（VPC）内部启动，这是一个逻辑虚拟网络，您可以在其中控制路由表、网络网关、公共互联网访问、可用区以及更多网络安全方面。这些选项允许对云安全至关重要的企业安全地运行云中的机器学习工作负载。您在这里可以选择将 SageMaker Studio 部署在 AWS 账户中创建的默认 VPC 中，或者您的 VPC 中。您可以选择一个或多个子网以实现高可用性。

许多组织在云中需要良好的互联网访问策略。您可以选择是否允许使用公共互联网，以及应该强制执行哪些安全组，这些安全组控制着入站和出站规则。最后但同样重要的是，您可以选择加密在 SageMaker Studio 中使用的存储，即 EFS 文件系统。

• 标签：您可以在 Studio 域中添加键值对形式的标签。这允许您或管理员根据附加的标签对资源进行分组，并了解云中的支出。

在查看标准选项后，让我们回到快速入门，因为在本书的上下文中，这足够简单直接：

1. 填写您的用户名。

2. 对于执行角色，我们创建一个新的角色。

图 2.3 – 使用快速入门设置 SageMaker Studio 域

1. 您可以选择允许访问任何 S3 存储桶、特定存储桶或除以下图中列出的四个其他规则之外的无额外存储桶。让我们选择无以练习最小权限访问。我们将使用稍后创建的 SageMaker 默认存储桶，它符合现有规则。点击创建角色：

图 2.4 – 创建 IAM 角色

1. 在您点击提交之前，请确保启用 Amazon SageMaker 项目模板和 JumpStart。选择提交。启动域名和用户配置文件可能需要几分钟时间。您可以随时休息一下，稍后再回来：

图 2.5 – SageMaker Studio 控制面板

1. 准备就绪后，点击 打开 Studio。

当您第一次打开它时，将创建一个 Jupyter 服务器应用程序，这需要几分钟时间。

接下来，让我们探索 SageMaker Studio UI。

漫步 SageMaker Studio UI

图 2.6 是 SageMaker Studio UI 和 Studio 启动器页面的截图。您可能会发现界面与 JupyterLab 界面非常相似。SageMaker Studio 确实建立在 JupyterLab 之上，并为其添加了许多附加功能，以在 IDE 内提供端到端的机器学习体验：

图 2.6 – SageMaker Studio UI – 左侧边栏用红色框标出

让我们谈谈 Studio UI 中的关键组件。

主要工作区域

主要工作区域是 启动器页面、笔记本、代码编辑器、终端和控制台所在的地方。除了来自 JupyterLab 的这些基本功能外，正如您将在本书中了解到的那样，SageMaker Studio 的自身功能，如 Data Wrangler、AutoPilot、JumpStart、特征存储、管道、模型监控和实验，也在主要工作区域中提供了丰富的用户体验。启动器页面是通往您可能希望创建的所有新资源的门户，例如新的 JumpStart 解决方案、新的特征存储、新的 MLOps 项目、新的笔记本和新的终端。

侧边栏

左侧带有七个图标（当您打开笔记本时为八个）的侧边栏是一个门户，通往您拥有或可能需要的所有资源，如 图 2.6 所示。从上到下，它们如下所示：

• 文件浏览器是您访问 EFS 文件系统上主目录中的文件并上传新文件的地方。

• Git 是您可以连接到 Git 仓库并交互式地对代码库执行 Git 操作的地方。

• 正在运行的终端和内核标签允许您查看、访问和关闭笔记本、内核和实例等计算资源。

• 命令显示了您可以在 Studio UI 中执行的命令和操作列表。

• 网络工具允许您访问笔记本的元数据。仅在笔记本在主要工作区域打开时显示。

• 打开标签显示打开标签的列表。

• SageMaker JumpStart 图标显示了启动的解决方案以及相关的训练作业和端点。

• SageMaker 组件和注册表列出了您可以查看和访问的项目、Data Wrangler 文件、管道、实验、模型、端点和特征存储。每个组件中还有一个搜索栏，方便您轻松找到资源。

主要工作区域右侧的侧边栏是 设置面板，允许您在从实验或模型监控作业创建可视化分析时编辑表格和图表属性，这是 SageMaker Studio 的一个出色功能。

在 SageMaker Studio 中运行 "hello world!"

让我们从一个非常基础的任务开始 – 打开一个笔记本，并运行一个每个编程书籍都会使用的非常简单的 Python 程序 – “hello world!”。

![图 2.7 – 创建 SageMaker Studio 笔记本

图 2.7 – 创建 SageMaker Studio 笔记本

1. 前往 笔记本和计算资源，选择 SageMaker 镜像（目前是可选的 – 数据科学 默认镜像就很好，但你也可以选择另一个镜像），然后在 笔记本 | Python 3 框中的 + 图标上点击。一个新的笔记本将会弹出。

2. 如果你注意到右上角紧挨着 Python 3 （数据科学）旁边有一个 未知，并且在底部状态栏中显示 内核：启动中...，如图 2.8 所示，这意味着笔记本仍在连接到计算资源。这应该需要大约一分钟。我们将在下一节 揭秘 SageMaker Studio 笔记本、实例和内核 中更深入地讨论幕后发生的事情。

![图 2.8 – 为新的 SageMaker Studio 笔记本启动内核

图 2.8 – 为新的 SageMaker Studio 笔记本启动内核

1. 如果你看到 Python 3 (数据科学) 内核镜像旁边有 2 vCPU + 4 GiB，这意味着笔记本已经连接到了拥有 2 个虚拟 CPU（vCPU）和 4 GiB RAM 的实例。让我们在笔记本的第一个单元中写下我们的第一行代码：

   print('hello world!')
   

现在让我们执行，如图下所示截图：

![图 2.9 – 笔记本已连接到内核，我们的 "hello world!" 程序正在运行

图 2.9 – 笔记本已连接到内核，我们的 "hello world!" 程序正在运行

太好了！我们刚刚在 SageMaker Studio 中启动了一个弹性笔记本并执行了我们的 "hello world!" 示例。然而，如果你执行代码时底部状态栏仍然显示 内核：启动中…，你可能会遇到以下错误：

Note: The kernel is still starting. Please execute this cell again after the kernel is started. 

这里发生了什么？让我们转换话题，来谈谈 SageMaker Studio 背后的基础设施。

揭秘 SageMaker Studio 笔记本、实例和内核

图 2.10 是 SageMaker Studio 域的架构图以及笔记本内核如何与其他组件相关联。这里有四个实体我们需要理解：

• EC2 实例：笔记本运行的硬件。你可以根据 vCPU、GPU 和内存量选择要使用的实例类型。实例类型决定了定价率，可以在 aws.amazon.com/sagemaker/pricing/ 找到。

• SageMaker 镜像：一个可以在 SageMaker Studio 上运行的容器镜像。它包含运行笔记本所需的语言包和其他文件。你可以在一个 EC2 实例上运行多个镜像。

• KernelGateway 应用程序：SageMaker 图像作为 KernelGateway 应用程序运行。SageMaker 图像与 KernelGateway 应用程序之间存在一对一的关系。

• 内核：在笔记本中运行代码的过程。SageMaker 图像中可以有多个内核。

到目前为止，我们作为 ipynb 文件将在 User1 主目录下的 Amazon EFS 文件系统 中创建。SageMaker Studio 将尝试将笔记本（前端）连接到一个满足要求的后端计算资源，即内核镜像和 EC2 实例类型。在 SageMaker Studio 中，我们还将启动的内核镜像称为 KernelGateway 应用程序。

![图 2.10 – SageMaker Studio IDE 背后的基础设施

![图片 B17447_02_10.jpg]

图 2.10 – SageMaker Studio IDE 背后的基础设施

重要提示

图片由以下链接提供：docs.aws.amazon.com/sagemaker/latest/dg/notebooks.html。

如果请求的计算资源可用，笔记本将立即连接并准备好进行编码。如果没有可用资源，就像我们在这个案例中，因为我们刚刚在该域中启动了我们第一个笔记本，SageMaker Studio 将启动一个计算实例（默认为 ml.t3.medium）并将内核镜像（我们选择的数据科学镜像）作为容器附加到计算实例中。

因此，我们看到 datascience-1-0-ml-t3-medium-xxxx KernelGateway 应用程序处于挂起状态。

![图 2.11 – SageMaker Studio 中 KernelGateway 应用程序正在启动

![图片 B17447_02_11.jpg]

图 2.11 – SageMaker Studio 中 KernelGateway 应用程序正在启动

一旦 KernelGateway 应用程序准备就绪，我们的笔记本也就准备好了。SageMaker Studio 中笔记本背后的这种创新机制允许用户（多租户）为我们在同一屋檐下运行的每个笔记本使用正确的计算资源。如果您点击 2 vCPU + 4 GiB，您将能够看到您正在使用的实例类型以及可供您使用的资源，如下所示：

![图 2.12 – 为笔记本选择实例

![图片 B17447_02_12.jpg]

图 2.12 – 为笔记本选择实例

有四种常用的不同类别的快速启动实例类型，即设计在 2 分钟内启动的实例。如果你取消选择仅快速启动复选框，你将看到 SageMaker Studio 中可用于笔记本的所有实例类型，包括非快速启动类型的实例。你可以自由切换到其他实例类型和内核镜像进行实验。你可以在左侧边栏的运行终端和内核中查看所有正在运行的实例、应用程序和实时笔记本会话。你应该使用电源按钮关闭你不再需要的正在运行的应用程序和内核会话，如以下截图所示，以终止和回收正在运行的实例上的资源。此外，你应该关闭你不再需要的正在运行的实例，以停止产生费用。

![Figure 2.13 – Viewing Running Terminals and Kernels from the left sidebar]

![img/B17447_02_13.jpg]

图 2.13 – 从左侧边栏查看正在运行的终端和内核

现在我们已经很好地理解了笔记本如何与实例和内核镜像协同工作，让我们进一步探索另一个我们将贯穿整本书以及你在 SageMaker Studio 的机器学习开发生命周期中会使用的重大资源。

使用 SageMaker Python SDK

SageMaker Studio 不仅仅是一个在笔记本中运行代码的地方。是的，SageMaker Studio 是一个开始编码和训练机器学习模型在弹性笔记本中的绝佳地方，但正如我们在本章的“介绍 SageMaker Studio 及其组件”部分所讨论的，它还有许多其他功能。

与 SageMaker 功能进行通信和工作的主要有两种方式。一种是通过具有 UI 前端组件的方式，例如 SageMaker Data Wrangler；另一种是通过软件开发工具包（SDK）。SDK 使开发者能够超越界面与 Amazon SageMaker 的世界进行交互。你可以访问 SageMaker 的可扩展、内置算法来处理你的数据。你可以通过编程方式运行 SageMaker Autopilot 作业。如果你使用 TensorFlow、PyTorch 或 MXNet 开发深度学习模型，你可以使用 SDK 与 SageMaker 的计算基础设施进行交互，以训练、处理和托管这些模型。你可以使用 SDK 创建特征存储。还有更多功能。我不会在本节中列举所有功能，因为我们将在未来的章节中主要使用和学习 SDK 来处理 SageMaker 功能，那时我们需要进行编码。

AWS 提供了几个使用 SageMaker 功能的 SDK，例如以下这些：

• SageMaker Python SDK，它提供了一个数据科学家熟悉的高级 API

• AWS SDK for Python (Boto3)，它提供了对 SageMaker API 和其他 AWS 服务的低级访问

• AWS SDK 支持其他编程语言（aws.amazon.com/sagemaker/resources/），取决于你的应用程序

对于许多数据科学家来说，由于其 API 设计，SageMaker Python SDK 是一个更自然的选择。在这本书中，我们将使用 SageMaker Python SDK。

SageMaker Python SDK 在所有完全管理的 SageMaker 内核映像中都是标准配置，因此您无需安装和管理不同版本。您只需在代码和笔记本中运行import sagemaker即可使用该库。您还可以在 SageMaker Studio 之外的地方使用 SageMaker Python SDK，例如在您的笔记本电脑或 AWS Lambda 上的无服务器应用程序中，前提是您有正确的 IAM 权限配置。

由于 SageMaker 是 AWS 中的云服务，在使用服务之前，您需要关注一些方面。以下代码是在给定环境中设置 SageMaker Python SDK 的典型方法。您将在本书中看到更多示例：

import sagemaker
session = sagemaker.Session()
bucket = session.default_bucket()
role = sagemaker.get_execution_role()

此代码片段执行以下操作：

1. 将 SageMaker Python SDK 导入到运行时。

2. 创建一个会话，允许您与 Amazon SageMaker API 和任何其他 AWS 服务进行交互。

3. 创建一个默认存储桶以供使用，并返回存储桶的名称。存储桶的格式为sagemaker-{region}-{AWS account ID}。

4. 获取本地可用的执行角色。在 SageMaker Studio 中，它是创建用户配置文件时分配的执行角色。一个角色应该有选择 S3 存储桶和执行与 SageMaker 相关操作权限，以便正确使用 SDK。我们的角色附带了AmazonSageMakerFullAccess策略，所以我们是有保障的。如果您在 PC 上使用 SDK，请确保您有一个 AWS 凭证，并且有一个 IAM 用户允许您执行与 SageMaker 相关的操作。

您可以打印出bucket和role以查看它们是什么。它们分别是 S3 存储桶和 IAM 角色的字符串值。role值是所有与云进行交互并执行操作的 API 所必需的。这很重要，因为在云中，安全性是首要任务。正如我们在第一章，“机器学习及其在云中的生命周期”中讨论的那样，在 AWS 中，您需要拥有有效和适当的权限才能执行和访问任何云资源。在执行具有 SageMaker 功能的操作时，role将用于在继续之前验证您是否有足够的权限。

作为开源库，您可以在github.com/aws/sagemaker-python-sdk处访问源代码，并在sagemaker.readthedocs.io/en/stable/index.html处查看文档。

摘要

在本章中，我们以高层次的视角介绍了 SageMaker Studio 的功能。我们将这些功能映射到典型机器学习生命周期的各个阶段，并讨论了为什么以及如何使用 SageMaker 在机器学习生命周期中。我们设置了 SageMaker Studio 域，并在 SageMaker Studio 中执行了我们第一个笔记本。我们学习了 SageMaker Studio 的基础设施以及如何为笔记本选择合适的内核镜像和计算实例。最后，我们讨论了关键工具 SageMaker Python SDK 背后的基本概念，以及它是如何与云和 SageMaker 交互的，因为这是我们在 SageMaker Studio 内进行许多未来活动的基础。

在下一章中，我们将通过使用 SageMaker Data Wrangler 准备一个用于机器学习用例的数据集来启动我们的机器学习之旅。你将了解到在 SageMaker Studio 中准备和处理数据是多么简单。

第二部分 - 使用 SageMaker Studio 的端到端机器学习生命周期

在本书的这一部分，你将获得对 SageMaker Studio 中每个组件在机器学习（ML）生命周期中的应用以及何时如何应用 SageMaker 特性的实际知识。

本节包含以下章节：

• 第三章, 使用 SageMaker Data Wrangler 进行数据准备

• 第四章, 使用 SageMaker Feature Store 构建特征库

• 第五章, 使用 SageMaker Studio IDE 构建和训练机器学习模型

• 第六章, 使用 SageMaker Clarify 检测机器学习偏差和解释模型

• 第七章, 在云端托管机器学习模型：最佳实践

• 第八章, 使用 SageMaker JumpStart 和 Autopilot 快速启动机器学习

第三章：使用 SageMaker 数据整理进行数据准备

使用 SageMaker 数据整理，你可以通过点击和点击的方式执行数据探索分析和数据预处理，以便进行机器学习建模。你将能够快速迭代数据转换和快速建模，以查看你的转换配方是否提高了模型性能，学习数据中是否存在对敏感群体的隐含偏见，并清楚地记录对处理数据的转换。

在本章中，我们将学习以下部分如何使用SageMaker 数据整理：

• 开始使用 SageMaker 数据整理进行客户流失预测

• 从源导入数据

• 使用可视化探索数据

• 应用转换

• 导出数据以进行机器学习训练

技术要求

对于本章，你需要访问github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter03中的材料。你需要确保你的 IAM 执行角色具有 AmazonAthenaFullAccess 策略。

开始使用 SageMaker 数据整理进行客户流失预测

客户流失对企业来说是一个严重的问题。如果你是业务所有者，失去客户绝对不是你希望看到的。你希望你的客户对你的产品或服务感到满意，并且永远继续使用它们。客户流失总是会发生，但能够理解客户为何离开服务或为何不再购买你的产品是至关重要的，提前预测会更好。

在本章中，我们将使用 SageMaker 数据整理进行数据探索分析和数据转换，并在本章结束时，我们将使用XGBoost 算法在整理后的数据上训练一个机器学习模型。

准备用例

我们将使用一个合成的chapter03/1-prepare_data.ipynb笔记本并执行它。你将获得数据副本，然后执行以下步骤：

1. 将数据分为三个数据框，customer_info、account_info和utility，以便我们可以在 SageMaker 数据整理中演示连接。

2. 随机屏蔽值以在数据中创建缺失值，以便我们可以演示 SageMaker 数据整理的功能。

3. 将三个数据框保存到 S3 存储桶中，并在 Amazon Athena 中使utility可用，以便我们可以模拟从多个来源导入数据。

启动 SageMaker 数据整理

你可以通过以下任何一种方式访问 SageMaker 数据整理：

• 点击文件 | 新建 | 数据整理流程 (图 3.1).

• 从启动器中，点击新建数据流 (图 3.1).

图 3.1 – 创建新的数据整理流程

• 从左侧侧边栏，SageMaker 资源，在下拉菜单中选择数据整理器，并点击 新建流程 (图 3.2)。

图 3.2 – 从注册表中创建新的数据整理流程文件。您也可以在这里找到您所有的流程文件

显然，从当前工作目录中创建的 untitled.flow。一个 数据流文件，扩展名为 .flow，是一个记录您使用 SageMaker 数据整理器从 UI 执行的所有步骤的文件。它是一个基于 JSON 的文件，可以轻松传输和重用。SageMaker Studio 和数据整理器可以解释 JSON 文件的内容，并呈现您为数据集执行的转换和分析。在此等待期间幕后发生的事情是 SageMaker Studio 正在启动一个数据整理器 KernelGateway 应用程序，并使用一个专门的 ml.m5.4xlarge 实例来支持我们在 SageMaker 数据整理器内部要执行的活动，以避免与其他笔记本内核的冲突。一旦准备就绪，您应该会看到 图 3.3 中展示的视图。

图 3.3 – 使用 SageMaker 数据整理器开始数据整理之旅

在我们继续之前，让我们通过在文件资源管理器中右键单击文件并选择 重命名 来将流程文件重命名为 wrangling-customer-churn.flow 或您喜欢的名称。

现在让我们开始使用 SageMaker 数据整理器。

从源导入数据

数据准备之旅的第一步是从源（s）导入数据。有四个选项可以从其中导入数据：chapter03/1-prepare_data.ipynb 笔记本。

从 S3 导入

请按照以下步骤将 CSV 文件导入到 S3 存储桶。我们希望加载 customer_info 和 account_info 表：

1. 从 图 3.3 中的视图选择 Amazon S3 作为源。您应该会看到一个 S3 存储桶列表。

2. 定位到具有命名约定 sagemaker-<region>-<accountid> 的 SageMaker 默认存储桶的路径。然后进入 sagemaker-studio-book/chapter03/data/ 文件夹以找到 CSV 文件。

3. 选择 telco_churn_customer_info.csv 并检查数据。确保文件类型是 CSV，并使用具有 16 个 vCPU 和 64 GiB RAM 的 ml.m5.4xlarge 实例。采样可以帮助确保在大数据集时数据集适合内存。点击 导入。

4. 对 telco_churn_account_info.csv 重复步骤 1–3。

图 3.4 – 导入两个 CSV 文件后的数据流

两个 CSV 文件加载完成后，您应该在 utility 中的 图 3.4 中看到视图。

从 Athena 导入

由于我们的utility表正在注册为 Amazon Athena 表，我们可以按照以下步骤从 Athena 导入它：

1. 点击导入选项卡，并选择Amazon Athena作为源。你应该能看到图 3.5中显示的视图。

2. 对于两个下拉选项，选择AwsDataCatalog作为数据目录，并选择telco_db作为数据库。对于高级配置，你可以勾选/取消勾选启用采样。如查询结果位置所示，你可以在该位置找到查询的输出。

图 3.5 – 从 Amazon Athena 导入数据

1. 选择数据库后，你将在我们的 Amazon Athena 数据库中的telco_churn_utility表右侧看到可用的表。你可以点击眼睛图标来预览表格，以便我们知道表格的外观，如图 3.6所示，以及如何形成一个更复杂的查询。

图 3.6 – 预览表格

1. 让我们通过查询获取所有数据。请将以下查询语句放入查询框中。然后点击运行：

   select * from telco_churn_utility
   

2. 你将在查询框下方找到查询结果。我们通过前面的语句获取了所有行和列。检查数据并点击顶部上的导入按钮。

3. 提供一个数据集名称，例如telco_churn_utility。

]你应该在数据流选项卡中看到所有三个表被加载到数据流中。当你悬停在任何一个最右侧的节点上并点击加号时，你会看到可以对这样的表执行的操作，如图 3.7所示。

![图 3.7 – 表格导入后的操作

图 3.7 – 表格导入后的操作

接下来，我们应该检查数据类型，或表的模式，以确保在导入过程中正确推断。

编辑数据类型

数据类型决定了数据整理器如何读取每个数据列以及如何处理它。数据整理器中有Long、Float、Boolean、String和Date类型。Long用于存储整数形式的数据。Float允许数据中有浮点数。Boolean表示二进制值，如0/1和是/否。String使数据成为基于文本的条目。Date以文本形式（dd-MM-yyyy）存储数据，但被解释为日期而不是字符串，并允许进行日期相关操作和比较。

可以应用于数据上的转换类型取决于数据类型。例如，你只能在Long和Float类型的列上应用数值运算。因此，在继续之前正确定义数据类型非常重要，即使数据整理器在导入时也会推断数据类型。

因此，让我们检查并编辑在数据整理器中导入的表的数据类型：

1. 从如图 3.7 所示的视图中，点击 telco_churn_account_info.csv 旁边的加号，并选择 Edit data types。

2. 如 图 3.8 所示，Long 整数类型。要更改它，在右侧面板的 CONFIGURE TYPES 中，点击 Account Length 列的 Type，然后选择 Long。

3. String。但它们应该是布尔类型以节省内存。通过在 CONFIGURE TYPES 中选择 Boolean 来将它们更改为 Boolean。

4. 点击 Preview 以查看数据类型更改后的数据外观。见图 3.8。

![Figure 3.8 – Editing data types in Data Wrangler]

![img/B17447_03_08.jpg]

图 3.8 – 在 Data Wrangler 中编辑数据类型

我们可以看到，Account Length 现在是 Long 类型，整数值保持不变，而 Int'l Plan 和 Vmail Plan 是 Boolean 类型，将是/否转换为 true/false，如表中所示。数据类型转换不会导致数据丢失或类似情况，因此我们可以继续应用编辑。

1. 点击 String 类型以将其更改为 Boolean 类型。这是因为值中的点 . 会使转换无效。你可以尝试更改它并预览更改。你会看到整个列被删除。我们将在稍后处理此列的转换。

我们已更改并确认了第一个表的数据类型。我们应该对其他两个表做同样的事情：

1. 点击 Back to data flow 返回数据流。

2. 点击 telco_churn_customer_info.csv 旁边的加号，并选择 Edit data types。

3. 将 Long 更改为 String。尽管此列包含整数值，但它们应被视为 locality 而不是数值特征。

4. 点击 Preview，然后 Apply。

5. 点击 Back to data flow 返回数据流。

6. 点击最后一个表 telco_churn_utility 旁边的加号，然后选择 Edit data types。

7. 将 cust_serv_calls 从 Float 更改为 Long。

8. 点击 Preview，然后 Apply。

9. 点击 Back to data flow 返回数据流。

我们已验证并修复了三个表的数据类型。现在是时候将它们合并为一个表了。

连接表

连接表是在处理多个数据源时最常见的一步，也是你在构建机器学习模型时丰富特征最重要的步骤。从关系数据库的角度思考。你的表保持某种关系，这允许你将它们全部放在一起以获得整体视图。我们将通过 customerID 列使用 Data Wrangler 将三个表连接起来。请按照以下步骤操作：

1. 点击 telco_churn_account_info.csv 旁边的加号，并选择 Join。你应该能看到如图 3.9 所示的视图。

![Figure 3.9 – Joining tables in SageMaker Data Wrangler]

![img/B17447_03_09.jpg]

图 3.9 – 在 SageMaker Data Wrangler 中连接表

1. telco_churn_account_info.csv 被选为 telco_churn_customer_info.csv 的 Right。你应该能看到两个表之间的链接，如图 3.10 所示。

![Figure 3.10 – Joining tables]

![img/B17447_03_10.jpg]

Figure 3.10 – 连接表

1. 点击配置以继续。

2. 如图 3.11所示，选择连接类型，因为我们希望获取所有数据，然后选择左侧和右侧的CustomerID作为连接的键。

![Figure 3.11 – 使用全外连接和选择键连接表

![img/B17447_03_11.jpg]

Figure 3.11 – 使用全外连接和选择键连接表

1. 点击CustomerID_0和CustomerID_1。我们将在应用转换部分稍后处理这个问题。

2. 在右上角点击添加以完成连接。

3. 现在我们需要连接最后一个表。点击连接表旁边的加号，并选择连接。

4. 选择右侧的telco_churn_utility，然后点击配置。

5. 再次，为右侧的customer_id选择CustomerID_0以进行连接。

6. 点击应用以预览合并后的数据集。是的，表已经合并，但键被重复了，这可以在应用转换部分稍后解决。不用担心。

7. 在右上角点击添加以完成连接。您将被带回到数据流。您应该看到如图图 3.12所示的数据流。

![Figure 3.12 – 连接三个表后的数据流

![img/B17447_03_12.jpg]

Figure 3.12 – 连接三个表后的数据流

注意

如果您发现有任何错误，请不要担心，只需点击有错误的节点旁边的加号，并选择删除以删除该节点。但请记住，如果您删除的不是最后一个节点，所有下游节点也将被删除。

我们已经准备好进入下一阶段：探索数据集！

使用可视化探索数据

探索性数据分析（EDA）为我们手头的数据提供洞察力，并帮助我们制定数据转换策略，以便机器学习建模可以表现得最好。使用编程分析并可视化数据是强大且可扩展的，但它需要大量的编码和开发。使用 SageMaker Data Wrangler，您可以在 UI 中轻松创建图表和图形。目前，SageMaker Data Wrangler 支持以下类型的图表和分析，无需编码：直方图、散点图、偏差报告、多重共线性、快速模型、目标泄露和表格摘要。让我们逐一看看它们是如何工作的。

使用直方图理解频率分布

直方图帮助我们理解一个变量的频率分布，该变量的值被分桶到离散的区间，并用条形图表示。我们可以使用 SageMaker Data Wrangler 中的直方图功能来查看，例如，白天通话者通话多长时间。为此，请按照以下步骤操作：

1. 点击2nd Join节点旁边的加号，并选择添加分析。您应该看到如图图 3.13所示的视图。

![Figure 3.13 – 在 SageMaker Data Wrangler 中添加分析

![img/B17447_03_13.jpg]

Figure 3.13 – 在 SageMaker Data Wrangler 中添加分析

1. 在day_mins_histogram中填写分析的名称。

2. 选择X 轴为day_mins。

3. 点击预览以查看图表，如图图 3.14所示。

![图 3.14 – 白天通话时间的分钟数直方图

图 3.14 – 白天通话时间的分钟数直方图

这太棒了！你在 SageMaker Data Wrangler 中创建了第一个可视化，以查看所有客户白天通话时间的频率分布。我们看到大多数客户的通话时间短于 8 分钟，很少有通话时间超过 12 分钟。但这只是一个总体视图。作为一名数据科学家，你可能想知道离开服务的客户与继续使用服务的客户的行为有何不同。我们应该根据目标状态：Churn?来切片和切块数据。我们可以通过按选项来完成。我们将继续修改图表，而不是保存当前的图表。

1. 选择按和点击预览。你应该看到更新后的图表，如图图 3.15所示。

![图 3.15 – 按目标变量 day_mins 的直方图

图 3.15 – 按目标变量 day_mins 的直方图

我们可以得出结论，离开服务的客户（True图表）最频繁的通话时间约为 6-10 分钟，而继续使用服务的客户（False图表）通话时间较短。多么有趣的观察。让我们保存这个分析。

1. 点击保存以保存并返回保存所有分析的页面。

在所有分析视图中，你可以看到在任何给定状态下为每个节点创建的图表和分析。我们已经创建了一个直方图。让我们继续创建另一个图表。

散点图

数据科学家可能会想知道白天通话较多的客户是否在晚上也经常通话。或者你可能好奇客户的账户长度和通话时间之间是否存在任何相关性。你可以使用散点图来可视化这个特征。让我们为数据创建一个散点图：

1. 在分析页面，点击右上角的创建新分析。

2. 选择AccountLength_CallTime_Scatter。

3. 选择X 轴为账户长度和Y 轴为day_mins。

4. 点击预览。你应该看到一个图表，如图图 3.16所示。

![图 3.16 – 账户长度与 day_mins 的散点图

图 3.16 – 账户长度与 day_mins 的散点图

从视觉上看，这两个变量之间似乎没有相关性。

直方图和散点图是 EDA 中最常用的两种工具，你可能很熟悉。使用 SageMaker Data Wrangler，你可以使用面向 ML 的分析，如 Quick Model，帮助你确定数据转换策略。

使用 Quick Model 预览 ML 模型性能

快速模型是另一个帮助你快速了解数据是否提供了任何预测能力的工具。这个工具很有用，可以经常使用。让我们看看它是如何工作的：

1. 在分析页面上，点击右上角的创建新分析。

2. 选择快速模型作为分析类型。

3. 在first_quickmodel中添加一个名称。

4. 选择流失？作为标签并点击预览。

图 3.17 – 快速模型结果，显示了测试集上模型性能的 F1 分数和特征重要性

SageMaker Data Wrangler 需要一分钟左右的时间，并返回一个条形图，如图图 3.17所示，显示了特征重要性和从给定数据集中随机分割的测试集上的 F1 分数。正如您在以下数据表中看到的那样，我们没有应用任何转换或数据清理。SageMaker Data Wrangler 使用一个流行的算法随机森林分类来训练模型并在一个保留的测试集上测试它。我们可以看到一个初步的 0.851 F1 分数，其中night_charge是预测客户流失状态的最重要特征。我们还可以看到有一些特征没有提供太多的预测能力，例如国际套餐和VMail 套餐。还有一些冗余的特征，如CustomerID_，这些特征不应该包含在建模中。这给我们提供了提示，确保在真正的建模中包括night_charge和其他高重要性特征，如果我们受限于可以使用的特征数量，我们可以排除国际套餐和VMail 套餐*。让我们在纸上记录分析结果。

1. 点击保存以保存分析。

正如我们刚刚进行了第一次快速建模，为了了解我们得到的模型性能，测试我们是否遇到了任何数据泄漏或目标泄漏问题也是一个好主意。

揭示目标泄漏

目标泄漏意味着数据中存在与目标变量高度相关或基本上是目标变量的代理表示的特征。例如，如果我们的数据集包含一个记录每个流失客户终止日期的列，那么这个列将包含流失的客户，如果我们将其包含在建模中，将导致建模精度极高。在这个例子中的问题是，在现实世界的预测时间，当模型的任务是预测未来的流失时，几乎不可能有终止日期。让我们看看我们的数据集中是否包含任何目标泄漏：

1. 在分析页面上，点击右上角的创建新分析。

2. 选择目标泄漏作为分析类型。

3. 在churn_target_leakage中添加一个名称。

4. 为最大特征数输入25，因为我们有 24 列在表中。

5. 选择分类作为问题类型。

6. 选择 Churn? 作为 Target 并点击 Preview。

![图 3.18 – 显示安全特征和可能冗余特征的目标泄漏结果（图表右侧带有图例着色）

图 3.18 – 显示安全特征和可能冗余特征的目标泄漏结果（图表右侧带有图例着色）

目标泄漏分析计算每个特征相对于目标的交叉验证 ROC 曲线下面积，如 图 3.18 上方的文本所述。此分析表明没有特征被确定为潜在的目标泄漏，这是一个好兆头。结果还证实了我们从快速建模练习中学到的结论：

a) night_charge 在预测流失方面很重要，并提供高水平的预测能力。

b) VMail Plan 提供的预测能力很小。

c) CustomerID_* 在数据集中是多余的。

让我们保存分析。

1. 点击 Save 保存分析。

我们通过最后两个分析了解了特征预测能力。我们还应该看看如何使用 SageMaker Data Wrangler 创建自定义可视化。

创建自定义可视化

SageMaker Data Wrangler 使用 Altair (altair-viz.github.io/) 以编程方式创建可视化。我们还可以在 SageMaker Data Wrangler 中使用代码创建任何自定义可视化，以获得更大的灵活性。例如，我们可以通过 Churn? 状态创建 night_charge 的箱线图，以了解两组的统计分布：

1. 在 All Analyses 页面上，点击右上角的 Create new analysis。

2. 点击紧挨着 Configure 的 Code 选项卡。

3. 添加一个名称，例如 boxplot_night_charge_by_churn。

4. 在编码区域输入以下代码。请确保导入 altair 库：

   # Table is available as variable 'df' of pandas dataframe
   # Output Altair chart is available as variable 'chart'
   import altair as alt
   chart=alt.Chart(df).mark_boxplot().encode(
       x='Churn?',
       y='night_charge')
   

5. 点击 Preview。

你应该看到一个表示 Churn? 状态分布的箱线图，如图 图 3.19 所示。如果你悬停在箱线图上，你可以看到数据的描述性统计。

![图 3.19 – 使用 Altair 库创建自定义箱线图

图 3.19 – 使用 Altair 库创建自定义箱线图

1. 点击 Save 保存自定义可视化。

值得注意的是，这些分析和可视化作为流程文件的一部分保存，这样你可以全面了解你如何处理数据。

通过这些分析，我们现在对如何转换和处理数据有了很好的理解。

应用转换

你可以轻松地使用 SageMaker Data Wrangler 应用数据转换，因为有许多内置的转换可以直接使用，无需任何编码。到目前为止，我们已经从需要处理以构建 ML 数据集的分析中观察到以下内容：

• 一些特征存在缺失数据。

• Churn? 列现在以字符串格式存储，值为 True. 和 False.。

• 连接后冗余的CustomerID_*列。

• 不提供预测能力的特征，包括但不限于Phone、VMail Plan和Int'l Plan。

我们还希望为了机器学习目的执行以下转换，因为我们想训练一个 XGBoost 模型来预测随后的Churn?状态。

• 对分类变量进行编码，即State和Area Code特征。

让我们开始吧：

1. 在数据流选项卡中，点击2nd Join节点旁边的加号，选择添加转换。您应该看到如图图 3.20所示的视图，左侧有一个表格，右侧有一系列转换列表。

![图 3.20 – 一个转换数据的工作空间。您可以在右侧展开每个转换以查看选项

![图片 B17447_03_20.jpg]

![图 3.20 – 一个转换数据的工作空间。您可以在右侧展开每个转换以查看选项

1. 要删除CustomerID_，点击管理列以展开转换，在转换中选择删除列，并选择CustomerID_0作为要删除的列*。

2. 如图 3.21所示，现在CustomerID_0已消失。

![图 3.21 – 在 SageMaker Data Wrangler 中删除列

![图片 B17447_03_21.jpg]

![图 3.21 – 在 SageMaker Data Wrangler 中删除列]

1. 点击添加以使转换生效。

2. 重复步骤 2-4 以删除CustomerID_1和customer_id。

如果操作正确，您应该在右侧的上一步选项卡上看到四个步骤，如图图 3.22所示。

![图 3.22 – 在“上一步”选项卡中查看之前的步骤

![图片 B17447_03_22.jpg]

![图 3.22 – 在“上一步”选项卡中查看之前的步骤

注意

如果您意识到您做了任何错误的事情并想恢复到之前的转换，您可以像图 3.22所示的那样，一次删除最后一步，直到恢复。

1. 继续处理cust_serv_calls中的缺失数据，展开输入列中的Account Length，以及近似中位数作为插补策略。我们可以留空输出列以指示 SageMaker Data Wrangler 覆盖现有列。

2. 点击102，如图图 3.23所示。

![图 3.23 – 账户长度填充了中位数，102

![图片 B17447_03_23.jpg]

![图 3.23 – 账户长度填充了中位数，102

1. 点击添加以使转换生效。

2. 对cust_serv_calls重复步骤 6-8。

有一些特征根据快速模型和目标泄漏分析没有提供太多预测能力，值得删除。Phone 是那些显示包含很少或没有有用信息的特征之一。另外，众所周知，当你注册一项服务时，电话号码大多是随机分配的。另一方面，尽管 VMail Plan 和 Int'l Plan 提供了没有预测信息，但它们是简单的 布尔 类型，确实有实际意义。将这些特征带入建模可能不会造成太大伤害。所以，让我们删除 Phone 特征。

1. 重复步骤 2–4 删除 Phone。

继续转换分类特征，我们有 State 和 Area Code，它们代表客户的地理位置。我们可以应用独热编码来转换它们。然而，我们可能会冒险删除 Area Code，下一个最好的行动是删除它。让我们对 State 进行独热编码并删除 Area Code。

1. 展开 编码分类，选择 独热编码 作为 转换，选择 状态 作为 输入列，选择 列 作为 输出样式，并保留其他选项为默认值。

2. 点击 状态 列被替换为 State_* 稀疏特征，每个特征代表客户是否处于特定状态（0 为假，1 为真）。

3. 点击 添加 使转换生效。

4. 重复步骤 2–4 删除 Area Code。

最后但同样重要的是，目标特征 Churn? 需要进行一些处理。它有一个奇怪的句号，这之前破坏了数据类型转换。此外，我们将要使用的 SageMaker 内置 XGBoost 算法要求目标特征位于第一列。让我们应用一个文本操作并移动该列。

1. 展开 Churn? 为 .（一个句号）作为 符号。

2. 点击 Churn? 已被移除，如 图 3.24 所示。点击 添加 使转换生效。

![图 3.24 – Churn? 列中移除了结束句号

![图片 B17447_03_24.jpg]

图 3.24 – Churn? 列中移除了结束句号

1. 我们现在可以使用数据类型解析器将 True/False 转换为布尔表示。展开 解析列类型，选择 Churn? 作为 列，并在 到 下拉菜单中选择 布尔。

2. 点击 布尔 类型。点击 添加 使转换生效。

3. 要将 Churn? 移到前面，展开 管理列，选择 移动列 作为 转换，选择 移动到开始 作为 移动类型，并选择 Churn? 作为 要移动的列。

4. 点击 预览 以查看转换。现在 Churn? 列成为第一个特征。点击 添加 使转换生效。

我们刚刚对数据集应用了十一个转换。我们可以运行一个快速建模分析，以确保我们在建模方面处于正确的轨道。

在处理数据时探索性能

在使用 SageMaker Data Wrangler 整理数据时，您可以在任何时间点添加分析。这允许您在关键转换后分析数据，并使用 Quick Model 验证预测能力。让我们为整理后的数据添加一个分析：

1. 点击分析选项卡。

2. 选择快速模型作为分析类型，在分析名称中添加一个名称，并选择流失？作为标签。

3. 点击预览以查看建模结果，如图图 3.25所示。模型的 F1 分数已从0.851提升到0.871。我们正走在正确的道路上。

![图 3.25 – 所有转换后的快速建模

![img/B17447_03_25.jpg]

图 3.25 – 所有转换后的快速建模

1. 点击添加将分析放置在画布上。

到目前为止，我们已经使用 SageMaker Data Wrangler 深入分析了电信客户流失数据集，并根据分析结果整理了数据。Quick Model 在预测客户流失方面显示出改进的 F1 分数。我们应该继续看看这项工作中我们有哪些选择。

导出数据用于机器学习训练

SageMaker Data Wrangler 支持以下导出选项：保存到 S3、管道、Python 代码和特征存储。我们迄今为止应用的数据转换尚未真正应用于数据。需要执行转换步骤以获取最终转换后的数据。当我们使用前面的选项导出我们的流程文件时，SageMaker Data Wrangler 会自动生成代码和笔记本，以指导您完成执行过程，这样我们就不必编写任何代码，但它为我们留下了自定义代码的灵活性。

四种导出选项满足了许多用例。保存到 S3是一个明显的选项，并且提供了很多灵活性。如果您希望将转换后的数据保存在 S3 桶中以便在 Amazon SageMaker 中训练机器学习模型，您也可以从 S3 本地下载它，并在需要时将其导入到其他工具中。管道选项创建了一个可以轻松重复调用的 SageMaker 管道。此类工作流程可以配置为事件触发或时间触发，以便您可以自动化数据转换作为管道。我们将在第十章中了解更多关于 SageMaker 管道的内容，使用 SageMaker Model Monitor 监控生产中的机器学习模型。Python 代码提供了最大的可见性和灵活性。您可以看到 Amazon SageMaker 如何实现每个转换，在 Spark 环境中运行代码，并获取处理后的数据。使用特征存储选项，您将获得一个自动生成的 Jupyter 笔记本，该笔记本将处理数据并在 SageMaker Feature Store 中创建一个特征组。我们将在第五章中了解更多关于 SageMaker Feature Store 的内容，使用 SageMaker Studio IDE 构建和训练机器学习模型。

对于这个示例，我想向您展示 保存到 S3 的选项，它包括在自动生成的笔记本中的机器学习训练：

1. 首先，保存流文件，以便导出的资源可以获取最新的更改。在菜单栏中，选择 文件->保存数据 Wrangler 流。

2. 点击 导出 选项卡，点击 步骤 节点，并在转换列表中选择最后一个步骤，移动列。通过点击一个步骤，将选择到所选步骤的所有步骤。

3. 在右上角点击 导出步骤，然后点击 保存到 S3。

应该会弹出一个新的 Python Jupyter 笔记本。这个笔记本包含使用 SageMaker Processing 处理 SageMaker Data Wrangler 流文件并保存处理后的数据到 S3 的代码。这是我们第一次遇到 SageMaker Processing 的实际应用。简而言之，它允许我们使用适当的计算资源来执行数据处理、模型评估和统计分析。使用 SageMaker Processing，您不再受 Studio 笔记本环境中本地可用的计算资源限制；相反，处理脚本和 Data Wrangler 流文件可以在适当大小的计算实例（s）上运行。您可以在以下步骤中看到实际操作。

1. 在 （可选）下一步 部分之前，请执行所有单元格。

   注意

   您可以在看到 💡 可配置设置 的部分配置笔记本。

SageMaker 处理作业可能需要几分钟。在处理作业结束时，处理后的数据将可用在 S3 桶中。您应该从单元格中看到以下输出：

Job results are saved to S3 path: s3://sagemaker-us-west-2-<account-id>/export-flow-04-01-52-59-xxxxxx/output/data-wrangler-flow-processing-04-01-52-59-xxxxxx

以下可选部分是有趣的建模部分。让我们运行这些步骤来训练一个使用 SageMaker 内置的 XGBoost 算法预测客户流失的机器学习模型。

1. 将 run_optional_steps 的值重新分配为 True：

   run_optional_steps = True
   

2. XGBoost 的默认目标指标 reg:squarederror 用于回归用例。由于我们有一个二分类用例，请将其更改为 binary:logistic：

   hyperparameters = {
       "max_depth":"5",
       "objective": "binary:logistic",
       "num_round": "10",
   }
   

3. 执行笔记本中所有剩余的单元格以启动训练作业。

训练作业可能需要一分钟左右的时间来完成。您可以在最后一个单元格中看到幕后操作的动作输出。我们将在 第五章**，使用 SageMaker Studio IDE 构建和训练机器学习模型 中了解更多关于 SageMaker 训练和训练算法的内容。一旦完成，模型也会保存在 S3 中，可用于在 Amazon SageMaker 中托管，或者模型也可以在本地使用。我们将在 第七章，云中托管机器学习模型：最佳实践 中了解更多关于托管选项的内容。

摘要

在本章中，我们展示了如何使用 SageMaker Data Wrangler 通过电信客户流失数据集进行操作。我们学习了如何从各种来源导入数据，合并表格，使用基于高级机器学习的分析进行数据分析，以及使用 SageMaker Data Wrangler 创建可视化。然后，我们无需编写任何代码，就可以轻松地使用 SageMaker Data Wrangler 内置的转换功能进行转换。在章节的最后，我们展示了如何将转换后的数据导出到 S3 桶，以及如何使用自动生成的笔记本轻松训练机器学习模型。

在下一章中，我们将学习机器学习项目中特征存储的概念，以及如何使用 SageMaker Feature Store 来设置特征存储。SageMaker Feature Store 统一了团队之间的特征，以便团队可以移除冗余的特征工程管道。由于其独特的设计模式，它还充当模型训练和模型服务用例的中央存储库，因为它具有离线存储以方便查询选择训练数据集，以及在线存储以支持模型服务环境中所需的低延迟事务。

第四章：使用 SageMaker Feature Store 构建特征存储库

特征存储允许您存储用于机器学习（ML）训练和推理的特征。它作为协作团队在 ML 用例中创建特征时的中央存储库，以防止重复和混淆的努力。Amazon SageMaker Feature Store 使在云中存储和访问训练和推理数据变得更加容易、快速且可重复。通过为您的 ML 生命周期构建的 SageMaker Feature Store 实例，您将能够管理始终在演变的特征，并使用它们进行训练和推理，从而有信心使用正确的特征。您还将能够通过拥有关于 ML 特征的单一事实来源，与您的同事更有效地协作。

在本章中，我们将涵盖以下主题：

• 理解特征存储的概念

• 开始使用 SageMaker Feature Store

• 从 SageMaker Feature Store 访问特征

技术要求

对于本章，您需要访问github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter04中的代码。您需要确保您的 IAM 执行角色具有AmazonSageMakerFeatureStoreAccess策略。

理解特征存储的概念

考虑以下场景：您是一位在汽车行业从事 ML 项目的数据科学家，与另一位数据科学家和几位数据工程师一起工作。您负责建模车辆燃油效率，而您的同事负责建模车辆性能。你们两人都使用来自汽车制造商的数据，这些数据由团队中的数据工程师在云中预处理并存储，作为模型的输入。

数据存储在不同的来源，例如 Amazon S3、Amazon 关系数据库服务（RDS）以及建立在 AWS 上的数据湖，具体取决于源数据的性质。您和您的数据科学家同事分别联系数据工程团队，以获取以最适合您各自建模练习的方式处理的数据。您没有意识到您的数据科学家同事的模型实际上共享一些共同的特征，但在您和您的工作空间中都创建并维护了一套新的特征。

随着项目的进行，数据工程团队报告称，管理不断增长的数据和特征足迹已成为一项挑战。当数据处理管道发生变化，或者汽车制造商修改和更新目录时，跟踪特征版本也变得繁琐。你发现自己一直在努力追踪哪些模型使用了哪些特征集或版本，这些特征来自众多表格和文件，用于你的代码和笔记。

这里是对团队面临挑战的总结：

• 尽管有一个中央数据工程团队，但数据和特征并没有集中存储。

• 数据科学家没有看到彼此创建和使用的特征，因此默认情况下是创建自己的。

• 因此，数据和特征被重复，给数据工程团队带来了负担。

• 特征的更新意味着需要有人管理的数据的另一个副本。

• 在机器学习生命周期的迭代中，模型和数据血缘难以维护。

特征存储是机器学习生命周期中的一个相对较新的概念，它旨在解决前述场景中观察到的挑战。特征存储的目标是拥有一个集中存储所有特征的存储库，用于所有模型，用于训练和推理，以及用于所有时间。所有特征意味着我们希望将来自不同来源的特征汇集到一个中心位置，并能够轻松找到它们。所有模型意味着我们希望构建各种模型的团队只从一个中心位置使用特征。训练和推理意味着我们希望在训练和托管目的时检索相同的特征，同时满足训练和推理应用中不同的运行时要求。所有时间意味着我们希望保留特征的整个生命周期版本，无论单个特征存储库中单个特征的更新和变化如何，以便数据科学家可以访问不同时间段的特征版本。

让我们来看看 SageMaker 特征存储中的关键组件和概念，这些组件和概念使其成为可能。

理解在线商店

在 SageMaker 特征存储中，在线商店是一种特征存储选项，旨在始终处于在线状态。在线意味着该存储库应该表现得像一个在线应用程序，能够立即响应用户的数据读写访问请求。"立即"可能具有主观性，但在技术术语中，这意味着低响应延迟，以便用户不会感到延迟。除了低延迟之外，另一个使在线商店"在线"的方面是它可以同时处理的交易高吞吐量。想象一下，有数十万用户访问你的应用程序；你不想让你的优秀客户失望。你希望你的在线应用程序能够以高吞吐量和低延迟处理流量。

为什么我们需要一个低延迟的在线商店？在许多机器学习用例中，机器学习推理需要立即响应用户在系统上的操作，并将推理结果返回给用户。推理过程通常包括查询特定数据点的特征，并将特征作为有效载荷发送到机器学习模型。例如，一个在线汽车保险报价应用程序有一个机器学习模型，它接受驾驶员信息来预测他们的风险水平并提出报价。该应用程序需要根据用户提供的汽车制造商从特征商店中提取与车辆相关的特征。您期望现代应用程序能够立即返回报价。因此，理想的架构应该将从特征商店提取特征和进行机器学习推理的延迟都保持得非常低。我们不能有一个机器学习模型可以立即响应，但需要几秒钟或几分钟来从各种数据库和位置收集特征的系统。

理解离线商店

SageMaker Feature Store 中的离线商店旨在通过保留所有记录以供使用来提供更灵活的功能。您将能够根据各种用例在任何给定条件和时间访问特征。但这也带来了对离线商店请求的更高延迟响应时间，因为离线商店使用较慢且成本较低的存储。

离线商店补充了在线商店，对于不需要低延迟的机器学习用例非常有用。例如，当构建用于合规目的的机器学习训练数据集以重现特定模型时，您需要访问历史特征以构建过去创建的模型。通常，机器学习训练并不期望在几秒钟内完成，因此在查询特征商店以获取训练数据时，您不一定需要亚秒级性能。

现在我们已经对 SageMaker Feature Store 中的关键组件和概念有了很好的理解，让我们通过一个用例来实际操作一下。

开始使用 SageMaker Feature Store

按照我们之前描述的场景，我们是一家汽车行业公司的数据科学团队。我们正在处理一个燃油效率数据集以创建机器学习模型。让我们使用 UCI 的 Auto MPG 数据集（archive.ics.uci.edu/ml/datasets/Auto+MPG），这是一个从 1970 年到 1982 年按制造商收集的车辆数据和燃油效率（以每加仑英里数衡量）的集合，来演示以下内容：

• 如何将特征摄入到特征商店

• 如何从在线商店和离线商店访问特征

• 如何逐年更新功能并使用版本控制（时间旅行）访问功能

作为先决条件，请导航到代码仓库并打开 chapter04/01-sagemaker_feature_store.ipynb 笔记本。首先，执行笔记本直到以下代码，从源数据读取到 pandas DataFrame：

data_url='https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
col_names=['mpg','cylinders', 'displacement', 'horsepower', 'weight', 'acceleration', 'model_year', 'origin', 'car_name']
df=pd.read_csv(data_url, delimiter='\s+', header=None, names=col_names, na_values='?')
df['car_name']=df['car_name'].astype('string')

此外，我们还将 car_name 列的数据类型转换为 string，这是 SageMaker Feature Store 所要求的。我们将在 创建特征组 部分稍后描述这意味着什么。

我们将按年份拆分 DataFrame，以便稍后模拟特征随年份的更新。因此，现在转换一个 DataFrame 的类型会更简单。以下单元格创建一个字典来保存按年份的 DataFrame，并添加一个新的 event_time 列来编码特征创建的时间。我们通过在每个相应的年份使用 Python 的 datetime 库在上午 8:00 添加 Unix 纪元时间来模拟它：

d_df = {}
for yr in df['model_year'].unique():
    print(yr)
    d_df[str(yr)]=df[df['model_year']==yr]
    d_df[str(yr)]['event_time']=datetime.datetime(1900+yr, 1, 1, 8, 0, 0).timestamp()

重要提示

任何要进入 SageMaker Feature Store 中特征组的特征表都需要一个表示事件时间的特征，例如本例中的 event_time。这允许我们通过时间进行特征的时间旅行和版本控制。

接下来，我们将开始与 SageMaker Feature Store 交互。

创建特征组

在 SageMaker Feature Store 中的 特征组 定义了元数据、特征定义、数据条目的唯一标识符以及其他 SageMaker Feature Store 配置。

创建特征组有两种方式 - 使用 SageMaker Python SDK 或 Studio UI。

通过遵循这些步骤（也在笔记本中），我们可以使用 SageMaker Python SDK 在 SageMaker Feature Store 中创建一个特征组：

1. 首先，我们使用 FeatureGroup 类创建一个名为 auto-mpg-<timestamp> 的 SageMaker 特征组：

   from sagemaker.feature_store.feature_group import FeatureGroup
   feature_group = FeatureGroup(name=feature_group_name, sagemaker_session=sess)
   

2. 接下来，我们需要让 SageMaker 特征组了解数据架构和定义。feature_group.load_feature_definitions() 是一个 API，用于从 pandas DataFrame 中加载架构和定义。API 会自动检测数据类型。我们还需要确保 DataFrame 中的特征配置为具有 SageMaker Feature Store 支持的数据类型。

   重要提示

   SageMaker Feature Store 支持的数据类型是 data 列，其中字符串作为 object 类型，这是为了向后兼容。从 pandas 1.0 版本开始，您可以明确请求使用 string 类型来表示包含字符串的列。SageMaker Feature Store 与 pandas 的 string 类型一起工作，而不是 object 类型。对于 event_time 列，可接受的数据类型是 string 或 fractional。对于 string 类型，事件时间必须以 ISO-8601 格式在 UTC 时间中，格式为 yyyy-MM-dd'T'HH:mm:ssZ 或 yyyy-MM-dd'T'HH:mm:ss.SSSZ。对于 fractional 类型，值应从 Unix 纪元时间开始，以毫秒精度表示。在我们的示例中，我们使用了 datetime 库返回的 Unix 纪元时间。

我们从第一个 DataFrame 中加载特征定义。您将在输出中看到加载到 feature_group 中的定义和数据类型：

feature_group.load_feature_definitions(data_frame=d_df['70'])
[FeatureDefinition(feature_name='mpg', feature_type=<FeatureTypeEnum.FRACTIONAL: 'Fractional'>),
 FeatureDefinition(feature_name='cylinders', feature_type=<FeatureTypeEnum.INTEGRAL: 'Integral'>),
 FeatureDefinition(feature_name='displacement', feature_type=<FeatureTypeEnum.FRACTIONAL: 'Fractional'>),
 FeatureDefinition(feature_name='horsepower', feature_type=<FeatureTypeEnum.FRACTIONAL: 'Fractional'>),
 FeatureDefinition(feature_name='weight', feature_type=<FeatureTypeEnum.FRACTIONAL: 'Fractional'>),
 FeatureDefinition(feature_name='acceleration', feature_type=<FeatureTypeEnum.FRACTIONAL: 'Fractional'>),
 FeatureDefinition(feature_name='model_year', feature_type=<FeatureTypeEnum.INTEGRAL: 'Integral'>),
 FeatureDefinition(feature_name='origin', feature_type=<FeatureTypeEnum.INTEGRAL: 'Integral'>),
 FeatureDefinition(feature_name='car_name', feature_type=<FeatureTypeEnum.STRING: 'String'>),
 FeatureDefinition(feature_name='event_time', feature_type=<FeatureTypeEnum.FRACTIONAL: 'Fractional'>)]

1. 定义加载后，我们可以在系统中创建 feature group：

   record_identifier_feature_name = 'car_name'
   event_time_feature_name = 'event_time'
   feature_group.create(
       s3_uri=f's3://{bucket}/{prefix}',
       record_identifier_name=record_identifier_feature_name,
       event_time_feature_name=event_time_feature_name,
       role_arn=role,
       enable_online_store=True,
       description=description
   )
   

在 create() 函数中，为特征组配置以下内容：

• 我们将 S3 存储桶位置指定给s3_uri参数，以表示我们想在当前位置为特征组设置离线存储。我们可以将其设置为False以禁用离线存储。

• 我们将enable_online_store设置为True以为特征组创建在线存储。如果您不需要在线存储，请将其设置为False以避免不必要的费用。

• 我们指出记录标识符是特征组中的car_name列，而event_time特征是event_time列。

这个创建操作是一个异步操作，需要几秒钟。下一个单元格中的check_feature_group_status()函数每 5 秒检查一次状态，并在特征组成功创建后返回单元格。您还可以在左侧侧边栏的SageMaker 组件和注册选项卡中查看 Studio UI 中的特征组列表，如图图 4.1所示。如果您点击列表中的特征组，您可以看到与特征组相关的所有信息，包括描述、特征定义和示例查询：

图 4.1 – 在 SageMaker Studio UI 中查看特征组

或者，您也可以从 UI 创建特征组。因为我们已经有数据在 pandas DataFrame 中，所以使用 SDK 加载定义非常直接。以下步骤演示了如何在 Studio UI 中创建特征组：

1. 点击创建特征组，如图图 4.1所示。

2. 在第一步，如图图 4.2所示，输入特征组名称、描述以及在线和离线存储的配置。对于离线存储，我们输入一个 S3 存储桶位置以存储离线存储数据，以及一个具有访问存储桶权限的 IAM 角色 ARN。在这个例子中，我们将使用也附加到 SageMaker Studio 用户配置文件的 SageMaker 执行角色。您可以从笔记本中的role变量中看到完整的 ARN。对于数据目录选项，让我们勾选自动创建 AWS Glue 表复选框，或者让 SageMaker 在三个字段中分配名称，或者我们自己分配名称。点击继续：

图 4.2 – 在 Studio UI 中配置特征组

1. 在第二步中，我们需要创建特征定义。我们可以使用JSON 编辑器批量粘贴定义，如图图 4.3:所示。

图 4.3 – 在 JSON 编辑器中编辑特征定义

1. 或者，我们可以使用表格选项卡通过易于使用的下拉列表编辑特征，如图图 4.4所示。完成编辑后，点击继续：

图 4.4 – 在表格中编辑特征定义

1. 在第三步，如图图 4.5所示，我们需要选择一个特征作为记录标识符（car_name）和另一个特征来标识事件时间（event_time）。点击继续以进行下一步：

图 4.5 – 选择记录标识符和事件时间特征

1. 然后，我们可以选择性地为特征组添加标签。点击创建特征组以继续。

   重要提示

   我演示了创建特征组的两种方法。我们只需要其中一种即可继续。让我们回到笔记本，并使用从 SageMaker Python SDK 创建的特征组。

一旦创建了特征组，我们就可以继续将数据摄取到特征组中。

将数据摄取到 SageMaker Feature Store

你可以以批量或流式方式将数据摄取到 SageMaker Feature Store 特征组中。sagemaker.feature_store SDK 中有一个 API，允许我们以异步和批量方式摄取 pandas DataFrame。对于流式摄取，sagemaker-featurestore-runtime API 使得将单个记录以低延迟放入特征组变得简单。这两种使特征摄取灵活的方法可以在 ML 生命周期的不同部分实现。

数据工程师或科学家可以使用批量摄取创建特征组并摄取第一批数据，这在探索阶段通常是这种情况。一旦构建了模型并准备提供服务，就必须考虑捕获新数据并将其摄取到特征存储中，以便可以使用丰富数据集迭代模型重新训练。如果你的数据以批量形式到来，你可以使用允许高效摄取大量数据的批量摄取。或者，如果你的模型作为实时应用程序的一部分部署，你可以使用流式摄取方法。在本节中，我们将了解批量摄取和流式摄取是如何工作的。

在我们的示例中，我们模拟了每年数据更新的情况，因为我们已经将数据集按年份切割成多个 DataFrame，每个年份的数据都有不同的event_time值。我们可以使用以下代码批量摄取每个 DataFrame：

for yr, df_auto in d_df.items():
    print(yr)
    print(df_auto.shape)
    feature_group.ingest(data_frame=df_auto, max_workers=1, max_processes = 1, wait=True)

我们将遍历d_df字典中的所有 DataFrame，并调用feature_group.ingest()方法来摄取每个 DataFrame。你可以使用max_workers和max_processes参数来控制摄取运行时间，其中max_processes数量的进程将并行创建以摄取 DataFrame 的不同分区，每个分区使用max_worker线程。.ingest()中的wait=True参数在继续之前等待 DataFrame 的摄取完成。

重要提示

虽然 SageMaker Python SDK 允许你创建特征组，处理特征定义，导入数据，并从离线存储查询数据，但sagemaker-featurestore-runtime boto3 SDK 允许你与在线存储进行交互（Get和Put）。特征在导入后立即在在线存储中可用，而在离线存储中使特征可用需要一些时间。

导入后，我们可以通过从在线存储中拉取一个样本记录来快速验证它，如下面的代码块所示，使用来自sagemaker-featurestore-runtime boto3 API 的get_record函数：

car_name = 'amc concord'
featurestore_runtime =  sess.boto_session.client(service_name='sagemaker-featurestore-runtime', 
                                                 region_name=region)
sample_record = featurestore_runtime.get_record(
    FeatureGroupName=feature_group_name, RecordIdentifierValueAsString=car_name
) 
sample_record

要以流式处理方式导入记录中的特征，我们可以使用sagemaker-featurestore-runtime boto3 API 中的put_record API 来导入单个数据记录，如下面的代码片段所示。此 API 提供了流式应用程序通常所需的低延迟。请注意，record是一个字典列表，其中每个特征都有一个FeatureName和ValueAsString对的FeatureName：

record = [{'FeatureName': 'mpg', 
           'ValueAsString': str(mpg)},
          {'FeatureName':'cylinders', 
           'ValueAsString': str(cylinders)},
          {'FeatureName':'displacement', 
           'ValueAsString': str(displacement)}, 
          {'FeatureName': 'horsepower', 
           'ValueAsString': str(horsepower)},
          {'FeatureName': 'weight', 
           'ValueAsString': str(weight)},
          {'FeatureName': 'acceleration', 
           'ValueAsString': str(acceleration)},
          {'FeatureName': 'model_year', 
           'ValueAsString': str(model_year)},
          {'FeatureName': 'origin', 
           'ValueAsString': str(origin)},
           'ValueAsString': str(car_name)},
          {'FeatureName': 'event_time', 
           'ValueAsString': str(int(round(time.time())))}]
featurestore_runtime.put_record(FeatureGroupName=feature_group_name, 
                                Record=record)

如果你已经启用了在线和离线存储，如我们的示例所示，SageMaker 会自动将在线存储中的特征同步到离线存储。当我们用年度数据更新特征组时，SageMaker 会将最新值追加到离线存储，以提供随时间变化的值的完整历史记录。

我们已经介绍了如何使用 SageMaker Python SDK 和sagemaker-featurestore-runtime boto3 API 分别以批量和流式处理方式将特征导入到 SageMaker 特征存储中的特征组。现在让我们看看将特征导入到 SageMaker 特征存储的另一种方式 – 从SageMaker Data Wrangler。

从 SageMaker Data Wrangler 导入

如果你已经阅读了第三章中的使用 SageMaker Data Wrangler 进行数据准备，你可能还记得，在使用 SageMaker Data Wrangler 的旅程结束时，有一个选项可以将数据导出到 SageMaker 特征存储。SageMaker Data Wrangler 会自动创建一个笔记本，其中包含所有代码，这样你就可以简单地执行单元格来将数据导入到特征组中。在笔记本中，它展示了 SageMaker 如何通过应用Amazon SageMaker Processing来启用导入，该应用将 SageMaker 特征存储作为输出目的地进行集成。要执行此操作，请按照以下步骤进行：

1. 打开在第三章中创建的flow文件，使用 SageMaker Data Wrangler 进行数据准备。

2. 前往导出选项卡以选择流程中的最后一个转换步骤。

3. 点击右上角的导出步骤按钮，如图 4.6 所示，并选择特征存储：

图 4.6 – 从 SageMaker Data Wrangler 将转换后的数据导出到 SageMaker 特征存储

1. 将弹出一个新的笔记本。遵循并执行单元格以启动 SageMaker Processing 作业。

处理结束后，将创建一个新的功能组，并在 SageMaker 功能存储中可用。

在我们创建功能组并将功能导入其中之后，我们可以继续了解我们如何与功能存储进行交互。

从 SageMaker 功能存储中访问功能

当您构建用于机器学习建模的训练数据集时，以及当您的应用程序对模型进行推理并需要与数据点相关的功能时，可以在功能存储中通过编程方式访问功能。我们将通过这些场景向您展示如何从 SageMaker 功能存储中访问功能。

在 Studio UI 中访问功能组

在 Studio UI 中，您可以在功能存储页面快速浏览账户中的功能组。在图 4.1中，您可以看到功能组的列表。您可以通过双击行来访问更多详细信息，例如功能组摘要、描述、功能定义和功能组标签，如图图 4.7所示：

图 4.7 – Studio UI 中功能组的详细信息

一旦您和您的团队开始在更多项目中使用 SageMaker 功能存储，您将在账户中拥有许多功能组。您可以使用功能组列表中的搜索栏搜索感兴趣的功能组：

图 4.8 – 在 Studio UI 中搜索功能组

要使用搜索栏，如图图 4.8所示，请执行以下操作：

1. 输入您要搜索的列名，例如，简短描述。

2. 输入搜索关键词；例如，我想找出哪个功能组的描述包含单词马力。

3. 然后应用过滤器，结果只显示满足搜索条件的一个功能组。

4. 您可以通过标签或功能组名称进行搜索。

通过标签搜索是一种灵活且强大的工具。在功能组标签选项卡中，您可以即时添加带有附加信息的标签，这将帮助您识别功能组。例如，在图 4.9中，我可以为功能组添加多达 50 个标签，以帮助我组织和搜索：

图 4.9 – 在 Studio UI 中为功能组添加标签

在 Studio 中的功能存储页面帮助我们识别正确的功能组，并在我们以编程方式访问功能之前了解更多关于功能定义和其他配置的信息。在下一节中，我们将学习如何访问功能。

访问离线存储 – 为分析和训练构建数据集

在构建训练数据集时，我们通常需要能够访问大量特征，访问特定时间或版本的特性，以及从多个特征组中组合信息。离线存储旨在支持此类活动。

在将特征添加到特征组后，SageMaker Feature Store 会将数据存入一个 S3 桶中，在AWS Glue Catalog中创建一个数据目录，在Amazon Athena中注册该目录，提供一个基于 SQL 的简单 API 进行查询，并返回一个 pandas DataFrame。我们可以使用以下代码片段将查询转换为 pandas DataFrame：

query = feature_group.athena_query()
table_name = query.table_name
query_string = ('SELECT * FROM "%s"' % table_name)
query.run(
        query_string=query_string,
        output_location=f's3://{bucket}/{prefix}/query_results/')
query.wait()
dataset = query.as_DataFrame()

在此代码片段中，我们使用特征组的athena_query()方法创建一个AthenaQuery类实例，这允许我们运行查询，将查询输出保存到 S3 位置，并返回一个 pandas DataFrame。table_name指的是我们可以在查询字符串中使用的 Athena 表名。在这里，我们的查询选择了特征表中的所有行和列。您可以查看返回的dataset，它包含 398 个条目，并注意除了我们定义的特征外，还有三个额外的列 – write_time、api_invocation_time和is_deleted。这三个在featurestore_runtime.get_record()的输出中也没有看到。它们是专门为离线存储创建的，以实现更好的特征管理和版本控制。我们将在稍后看到它们如何被使用。

现在我们已经了解了如何与特征存储进行交互和查询。让我们考虑这个用例：我们希望使用 1979 年之前所有制造的车辆来构建训练数据。我们的查询将如下所示：

query_string_2 = '''
SELECT * FROM "%s" WHERE model_year < 79
''' % table_name

如果我们运行查询，我们将得到一个包含 280 个条目的 DataFrame（dataset_2），这是完整表（398）的一个子集。

考虑另一种场景：我们希望使用 1979 年之前所有制造的车辆来构建训练数据，但只考虑最新型号年的规格。我们可以构建一个点时间查询，如下面的代码块所示。这也被称为时间旅行（回到过去获取该点的特征）：

query_string_3 = '''
SELECT *
FROM
    (SELECT *,
         row_number()
        OVER (PARTITION BY car_name
    ORDER BY  event_time desc, Api_Invocation_Time DESC, write_time DESC) AS row_number
    FROM "%s"
    where event_time < %.f)
WHERE row_number = 1 and
NOT is_deleted
''' % (table_name, datetime.datetime(1979, 1, 1, 8, 0, 0).timestamp())

使用此查询，我们得到一个包含 212 个条目（dataset_3）的 DataFrame。我们可以比较最后两个 DataFrame 中amc gremlin汽车的条目，如图 4.10 所示：

图 4.10 – 点时间查询（dataset_3）返回了截至 1979 年的车辆最新数据，而不是 1979 年之前的所有条目（dataset_2）

多亏了存储在 SageMaker Feature Store 中的详细时间属性以及特征，我们可以对特征组执行复杂的版本控制和点时间查询。我们可以看到dataset_3只包含一个车辆的条目，而dataset_2包含了该车辆的所有历史条目：

![图 4.11 – 帮助您使用特征组离线商店执行常见任务的示例查询

![img/B17447_05_011.jpg]

图 4.11 – 帮助您使用特征组离线商店执行常见任务的示例查询

SageMaker Feature Store 中的离线商店可以非常灵活。在特征商店 UI 中，您可以在样本查询标签页上找到针对离线商店的几个查询示例，如图4.11所示。

现在，让我们将注意力转向从在线商店访问功能。

访问在线商店 – 低延迟特征检索

SageMaker Feature Store 的在线商店功能提供低至个位数的毫秒延迟和高吞吐量。这适用于将特征以流式架构摄入云中，并且模型推理具有实时和流式特性的用例。通过sagemaker-featurestore-runtime boto3 API 可以访问特征组的在线商店，这也是我们在将数据摄入 SageMaker Feature Store部分所使用的：

car_name = 'amc gremlin'
featurestore_runtime =  sess.boto_session.client(service_name='sagemaker-featurestore-runtime', region_name=region)
amc_gremlin = featurestore_runtime.get_record(
    FeatureGroupName=feature_group_name, 
    RecordIdentifierValueAsString=car_name
)
amc_gremlin['Record']
[{'FeatureName': 'mpg', 'ValueAsString': '20.0'},
 {'FeatureName': 'cylinders', 'ValueAsString': '6'},
 {'FeatureName': 'displacement', 'ValueAsString': '232.0'},
 {'FeatureName': 'horsepower', 'ValueAsString': '100.0'},
 {'FeatureName': 'weight', 'ValueAsString': '2914.0'},
 {'FeatureName': 'acceleration', 'ValueAsString': '16.0'},
 {'FeatureName': 'model_year', 'ValueAsString': '75'},
 {'FeatureName': 'origin', 'ValueAsString': '1'},
 {'FeatureName': 'car_name', 'ValueAsString': 'amc gremlin'},
 {'FeatureName': 'event_time', 'ValueAsString': '157795200.0'}]

我们以amc gremlin作为示例车辆来检索特征。我们使用boto3的get_record API 来访问车辆的特性。API 的输出（amc_gremlin）是一个 Python 字典。特征值在Record字段中返回。如果您仔细观察，您会注意到车辆的model_year值为75。这表明在线商店只保留最新的条目。

我们还可以使用batch_get_record API 批量检索多个记录和特征。我们可以通过一个车辆名称列表检索多个记录，并通过一个所需特征的列表选择特征子集。如果不提供FeatureNames，则返回所有特征：

car_names = ['amc gremlin', 'amc concord', 'dodge colt']
feature_names = ['cylinders', 'displacement', 'horsepower'] 
sample_batch_records=featurestore_runtime.batch_get_record(
   Identifiers=[
     {'FeatureGroupName': feature_group_name,
       'RecordIdentifiersValueAsString': car_names,
       'FeatureNames': feature_names},
   ]
)
sample_batch_records['Records'][0]['Record'] # indexing first record
[{'FeatureName': 'cylinders', 'ValueAsString': '4'},
 {'FeatureName': 'displacement', 'ValueAsString': '151.0'},
 {'FeatureName': 'horsepower', 'ValueAsString': '90.0'}]

您可以在您的 Web 应用程序中运行这些代码行以以个位数的毫秒延迟检索特征，用于 ML 推理。使用 SageMaker Feature Store，您可以快速检索给定数据索引的特征，并在云中进行 ML 推理。

摘要

在本章中，我们从 ML 的角度学习了特征存储的概念。我们描述了 Amazon SageMaker Feature Store 的功能，并介绍了在开发 ML 模型时使用公共汽车用数据集的几个特征存储用例。在示例代码中，我们向您展示了如何在 SageMaker Feature Store 中创建特征组，以及如何将特征和数据摄入特征组。我们还向您展示了如何为模型训练目的从离线商店访问特征，以及如何执行点时间（时间旅行）特征查询，这在需要访问过去特征时非常有用。最后，我们向您展示了如何为 ML 推理目的从在线商店访问特征。

在下一章中，我们将进入使用 SageMaker Studio IDE 构建和训练机器学习模型的主题。在典型的机器学习生命周期中，构建和训练机器学习模型可能会具有挑战性，因为它耗时且计算资源密集。您将学习如何使用 SageMaker Studio IDE 轻松构建和训练机器学习模型。

第五章: 使用 SageMaker Studio IDE 构建和训练 ML 模型

使用 SageMaker Studio 构建和训练一个 机器学习（ML）模型可以变得简单。它是一个 集成开发环境（IDE），专为 ML 开发者设计，用于大规模和高效地构建和训练 ML 模型。为了训练一个 ML 模型，你可能之前已经处理过自己或团队管理计算基础设施的繁琐开销，以正确地训练 ML 模型。你也可能经历过计算资源限制，无论是在桌面机器上还是在云资源中，你被分配了一个固定大小的实例。当你使用 SageMaker Studio 进行开发时，不再有配置和管理计算基础设施的挫折，因为你可以轻松地利用 SageMaker Studio 中的弹性计算以及其对复杂 ML 算法和框架的广泛支持，以满足你的 ML 用例。

在本章中，我们将涵盖以下主题：

• 使用 SageMaker 内置算法训练模型

• 使用流行框架编写的代码进行训练

• 使用 SageMaker Notebook 进行开发和协作

技术要求

对于本章，你需要访问提供的代码，代码位于 github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter05。

使用 SageMaker 内置算法训练模型

当你想要在 SageMaker Studio 的笔记本中构建一个针对你的 ML 用例和数据的 ML 模型时，最简单的方法之一是使用 SageMaker 的内置算法。使用内置算法有两个优点：

• 内置算法不需要你编写任何复杂的 ML 代码。你只需要提供你的数据，确保数据格式符合算法的要求，并指定超参数和计算资源。

• 内置算法针对 AWS 计算基础设施进行了优化，并且开箱即用即可扩展。轻松地在多个计算实例上执行分布式训练，并/或启用 GPU 支持，以加快训练时间。

SageMaker 内置算法套件提供了适用于最常见机器学习用例的算法。以下类别中都有算法：监督学习、无监督学习、图像分析和文本分析。最值得注意的是，对于监督学习和无监督学习，分别有XGBoost和k-means用于表格数据，以及用于图像分析的图像分类、目标检测和语义分割。对于文本分析，我们有word2vec、文本分类和序列到序列算法。这些只是我们提到的每个类别的示例算法。还有更多有用的算法可供选择，但我不一一列举。您可以访问docs.aws.amazon.com/sagemaker/latest/dg/algos.html查看完整列表和更多详细信息。

注意

算法的 GPU 支持和分布式训练能力各不相同。请访问docs.aws.amazon.com/sagemaker/latest/dg/common-info-all-im-models.html以了解每个算法的 GPU 和分布式训练支持。

让我们通过一个用例和一个算法来展示如何使用 SageMaker 的内置算法。

简易训练 NLP 模型

使用 SageMaker 的内置算法训练 ML 模型不需要编写任何 ML 代码。我们将通过一个 NLP 用例来查看如何使用来自DBpedia（www.dbpedia.org/）的 DBpedia 本体数据集将句子分类到类别中，该数据集包含 560,000 个训练样本和 70,000 个测试样本的维基百科文章的标题和摘要。请使用Python 3 (Data Science)内核和ml.t3.medium实例打开存储库中的chapter05/01-built_in_algorithm_text_classification.ipynb笔记本。

在笔记本中，我们首先下载数据集并检查它，以了解我们需要如何处理数据，如下面的代码片段所示：

!wget -q https://github.com/le-scientifique/torchDatasets/raw/master/dbpedia_csv.tar.gz
!tar -xzf dbpedia_csv.tar.gz
!head dbpedia_csv/train.csv -n 3
!cat dbpedia_csv/classes.txt

我们看到数据，dbpedia_csv/train.csv，格式为<类别索引>,<标题>,<摘要>。还有一个名为dbpedia_csv/classes.txt的文件，记录了类别，其顺序与dbpedia_csv/train.csv中看到的类别索引相对应。

这是一个文本分类问题：给定一篇文章的摘要，我们想要构建一个模型来预测和分类这个摘要所属的类别。当处理大量文本文档时，这是一个常见的用例，例如来自维基百科网站的数据集，其中包含来自维基百科文章的标题和摘要。几乎不可能使用人工审查来组织所有文档。

对于此类用例，一个合适的内置算法是BlazingText。BlazingText 对 Word2vec（无监督）和文本分类（监督）都有高度优化的实现。Word2vec 算法可以将文本转换为向量表示，或词嵌入，适用于任何下游 NLP 应用，如情感分析或命名实体识别。文本分类可以将文档分类到类别中。这对于我们的用例和数据集来说非常合适。

在使用 SageMaker 的内置算法时，准备训练数据是关键。使用 BlazingText 进行文本分类需要将每个数据点格式化为__label__<class> text…。以下是一个示例：

__label__latin Lorem ipsum dolor sit amet , consectetur adipiscing elit , sed do eiusmod tempor incididunt ut labore et dolore magna aliqua . 

我们使用一个preprocess函数，该函数调用transform_text函数来标记化摘要的每一行。在transform_text函数中，我们使用nltk库中的sentence tokenizer，即punkt。我们预处理训练和测试文件。为了保持处理时间可控，我们只使用 20%的训练数据，如下面的代码片段所示：

preprocess("dbpedia_csv/train.csv", "dbpedia.train", keep=0.2)
preprocess("dbpedia_csv/test.csv", "dbpedia.validation")
!head -n 1 dbpedia.train 
__label__Company automatic electric automatic electric company ( ae ) was the largest of the manufacturing units of the automatic electric group . it was a telephone equipment supplier for independent telephone companies in north america and also had a world-wide presence . with its line of automatic telephone exchanges it was also a long-term supplier of switching equipment to the bell system starting in 1919.

我们可以看到，现在我们已经有了预期的数据格式。请随意使用preprocess中的keep参数将训练集扩展到更高的百分比。预处理后，我们就可以调用内置算法了。

SageMaker 的内置算法是完全管理的容器，可以通过简单的 SDK 调用访问。以下代码允许我们使用 BlazingText 算法进行文本分类：

image=sagemaker.image_uris.retrieve(framework='blazingtext', 
                                    region=region, 
                                    version='1')
print(image)
433757028032.dkr.ecr.us-west-2.amazonaws.com/blazingtext:1

执行后，我们得到一个名为image的变量中的字符串。你可能想知道，这个看起来像 URL 路径的字符串是什么？这如何是一个模型训练算法？

容器技术是 SageMaker 托管训练的核心。容器技术允许 SageMaker 具有与任何框架和任何运行时要求的工作灵活性。SageMaker 不是使用笔记本中的运行时设置和使用笔记本背后的计算资源进行模型训练，而是将您提供的数据和一个包含运行时设置和代码库的容器镜像带到 SageMaker 托管的计算基础设施中进行模型训练。

在image路径中指向一个存储在Amazon Elastic Container Registry（ECR）中的容器镜像，其中包含 BlazingText ML 算法。我们可以使用它通过 SageMaker 估计器启动一个模型训练作业。

SageMaker 估计器是托管模型训练的关键构建块，它使我们能够通过简单的 API 命令模型训练作业的各个方面。以下是如何使用 SageMaker 的 BlazingText 算法设置训练作业的代码片段：

estimator = sagemaker.estimator.estimator(
            image,
            role,
            instance_count=1,
            instance_type='ml.c5.2xlarge',
            volume_size=30,
            max_run=360000,
            input_mode='File',
            enable_sagemaker_metrics=True,
            output_path=s3_output_location,
            hyperparameters={
                'mode': 'supervised',
                'epochs': 20,
                'min_count': 2,
                'learning_rate': 0.05,
                'vector_dim': 10,
                'early_stopping': True,
                'patience': 4,
                'min_epochs': 5,
                'word_ngrams': 2,
            },
)

最值得注意的是，输入到估计器的参数如下：

• 作为容器的算法，image

• 训练作业的hyperparameters

• 作业所需的计算资源，instance_type、instance_count和volume_size

• IAM 执行角色，role

如您所见，我们不仅指定了算法选项，还指导 SageMaker 我们需要哪些云计算资源来完成这次模型训练。我们请求一个 ml.c5.2xlarge 实例，这是一个具有高性能处理器的计算优化实例，为此次训练作业提供 30 GB 的存储空间。它允许我们在原型设计期间使用轻量级、廉价的实例类型（ml.t3.medium）进行笔记本环境，并在更强大的实例类型上完成全规模训练以更快地完成任务。

我们已经设置了算法和计算资源；接下来，我们需要将估计器与训练数据关联起来。在准备完数据后，我们需要将数据上传到 S3 桶中，以便 SageMaker 训练作业可以访问 ml.c5.4xlarge 实例。我们通过简单地调用 estimator.fit() 并传入数据来启动训练：

train_channel = prefix + '/train'
validation_channel = prefix + '/validation'
sess.upload_data(path='dbpedia_csv/dbpedia.train', bucket=bucket, key_prefix=train_channel)
sess.upload_data(path='dbpedia_csv/dbpedia.validation', bucket=bucket, key_prefix=validation_channel)
s3_train_data = f's3://{bucket}/{train_channel}'
s3_validation_data = f's3://{bucket}/{validation_channel}'
print(s3_train_data)
print(s3_validation_data)
data_channels = {'train': s3_train_data, 
                 'validation': s3_validation_data}
exp_datetime = strftime('%Y-%m-%d-%H-%M-%S', gmtime())
jobname = f'dbpedia-blazingtext-{exp_datetime}'
estimator.fit(inputs=data_channels,
              job_name=jobname,
              logs=True)

您可以在笔记本中查看作业日志并观察以下内容：

• SageMaker 为此训练作业启动一个 ml.c5.2xlarge 实例。

• SageMaker 从 S3 下载数据，并从 ECR 下载 BlazingText 容器镜像。

• SageMaker 运行模型训练，并将训练和验证准确率记录在下面的单元格输出中：

  #train_accuracy: 0.9961
  Number of train examples: 112000
  #validation_accuracy: 0.9766
  Number of validation examples: 70000
  

训练作业的单元格输出也存在于 estimator(…, enable_sagemaker_metrics=True) 中，并自动发送到 Amazon CloudWatch Metrics。即使笔记本意外删除，这也为我们提供了对训练作业的治理。

一旦训练作业完成，您可以在 estimator.model_data 中访问训练好的模型，该模型可以用于后续的托管和推理，无论是在云中，这是我们在下一章将深入探讨的主题，还是在安装了 fastText 程序的计算机上。您可以使用以下代码块访问模型：

!aws s3 cp {estimator.model_data} ./dbpedia_csv/
%%sh
cd dbpedia_csv/
tar -zxf model.tar.gz
# Use the model archive with fastText
# eg. fasttext predict ./model.bin test.txt

注意

BlazingText 是 FastText 的 GPU 加速版本。FastText (fasttext.cc/) 是一个开源库，可以执行词嵌入生成（无监督）和文本分类（监督）。BlazingText 和 FastText 创建的模型是兼容的。

我们刚刚创建了一个复杂的文本分类模型，该模型能够在验证数据上以 0.9766 的准确率对 DBpedia 中的文档类别进行分类，且使用的 ML 代码量最少。

让我们再设置一个机器学习实验管理框架，SageMaker Experiments，以跟踪我们在本章中启动的作业。

使用 SageMaker Experiments 管理训练作业

作为数据科学家，我们可能都遇到过一种棘手的情况，即模型训练运行的次数可以非常快地增长到难以追踪最佳模型的各种实验设置的程度，例如数据集版本、超参数和算法。在 SageMaker Studio 中，您可以使用SageMaker Experiments轻松跟踪训练运行中的实验，并在实验和试验组件 UI 中可视化它们。SageMaker Experiments 是一个开源项目(github.com/aws/sagemaker-experiments)，可以通过 Python SDK 编程访问。

在 SageMaker Experiments 中，实验是一系列试验运行集合，这些运行是 ML 工作流的执行，可能包含试验组件，如数据处理和模型训练。

让我们继续使用chapter05/01-built_in_algorithm_text_classification.ipynb笔记本，看看我们如何使用 SageMaker Experiments 设置实验和试验，以跟踪具有不同学习率的训练作业，以便我们可以在 SageMaker Studio 中轻松比较试验的性能，以下是一个片段：

1. 首先，我们在笔记本内核中安装sagemaker-experiments SDK：

   !pip install -q sagemaker-experiments
   

2. 然后，我们创建一个名为dbpedia-text-classification的实验，我们可以使用smexperiments库来存储与此模型训练用例相关的所有作业：

   from smexperiments.experiment import Experiment
   from smexperiments.trial import Trial
   from botocore.exceptions import ClientError
   from time import gmtime, strftime
   import time
   experiment_name = 'dbpedia-text-classification'
   try:
       experiment = Experiment.create(
           experiment_name=experiment_name, 
           description='Training a text classification model using dbpedia dataset.')
   except ClientError as e:
       print(f'{experiment_name} experiment already exists! Reusing the existing experiment.')
   

3. 然后，我们创建一个名为create_estimator()的实用函数，它有一个输入参数learning_rate，以便在以后迭代各种学习率时使用方便：

   def create_estimator(learning_rate):
       hyperparameters={'mode': 'supervised',
                        'epochs': 40,
                        'min_count': 2,
                        'learning_rate': learning_rate,
                        'vector_dim': 10,
                        'early_stopping': True,
                        'patience': 4,
                        'min_epochs': 5,
                        'word_ngrams': 2}
       estimator = sagemaker.estimator.estimator(
                       image,
                       role,
                       instance_count=1,
                       instance_type='ml.c4.4xlarge',
                       volume_size=30,
                       max_run=360000,
                       input_mode='File',
                       enable_sagemaker_metrics=True,
                       output_path=s3_output_location,
                       hyperparameters=hyperparameters)
       return estimator
   

4. 让我们在for循环中运行三个具有不同学习率的训练作业，以便了解准确率如何变化：

   for lr in [0.1, 0.01, 0.001]:
       exp_datetime = strftime('%Y-%m-%d-%H-%M-%S', gmtime())
       jobname = f'dbpedia-blazingtext-{exp_datetime}'
       exp_trial = Trial.create(
           experiment_name=experiment_name, 
           trial_name=jobname)
       experiment_config={
           'ExperimentName': experiment_name,
           'TrialName': exp_trial.trial_name,
           'TrialComponentDisplayName': 'Training'}
       estimator = create_estimator(learning_rate=lr)    
       estimator.fit(inputs=data_channels,
                job_name=jobname,
                experiment_config=experiment_config,
                wait=False)
   

在for循环中，我们创建唯一的训练作业名称dbpedia-blazingtext-{exp_datetime}，将其与一个试验exp_trial和一个实验配置experiment_config相关联，以存储信息。然后我们将experiment_config传递给estimator.fit()函数，SageMaker 将自动为我们跟踪实验。

注意

我们在estimator.fit()调用中放置wait=False。这允许训练作业异步运行，这意味着单元格会立即返回，而不是被进程持有直到训练完成。实际上，我们的具有不同学习率的作业是并行运行的，每个作业都使用自己的 SageMaker 管理的实例进行训练。

在 SageMaker Studio 中，您可以使用 SageMaker Experiments 轻松比较这些训练作业的结果。我们可以在 SageMaker Studio UI 中创建一个图表来比较三个作业在不同学习率下的准确率：

1. 如图 5.1所示，点击左侧边栏中的SageMaker 组件和注册表：

图 5.1 – 从左侧边栏查看实验和试验

1. 在下拉菜单中选择实验和试验，如图图 5.1所示。

2. 右键单击dbpedia-text-classification实验条目并选择在试验组件列表中打开。

3. 主工作区域将弹出一个新视图。您可以配置列以显示准确率和学习率，如图图 5.2所示。我们可以看到验证:准确率和训练:准确率与三个学习率设置相关。当学习率设置为0.01时，训练和验证准确率最为平衡。学习率为 0.1 时过拟合，而学习率为 0.001 时欠拟合。

图 5.2 – 查看和比较训练作业

1. 我们可以创建一个验证:准确率与学习率的折线图。多选三个试验组件，然后在右上角点击添加图表。将弹出一个新视图。按照图 5.3所示配置图表属性。您将得到一个显示验证:准确率与学习率之间关系的图表。

图 5.3 – 比较和图表化验证准确率与学习率

SageMaker Experiments 在您开始在 SageMaker Studio 中以规模构建机器学习项目时管理作业和资源以及比较性能非常有用。

注意

没有设置experiment_config的训练和处理作业将被放置在未分配的试验组件中。

更多的时候，您已经有一些使用流行框架（如 TensorFlow 和 PyTorch）来训练模型的机器学习项目。您也可以使用 SageMaker 的完全托管训练功能来运行它们。

使用流行框架编写的代码进行训练

由于我们之前提到的容器技术，SageMaker 的完全托管训练与您喜欢的 ML 框架也兼容。您可能一直在使用 Tensorflow、PyTorch、Hugging Face、MXNet、scikit-learn 以及更多。您可以使用 SageMaker 轻松使用它们，以便您可以使用其完全托管的训练功能，并从配置适当规模的计算基础设施的便利性中受益。SageMaker 允许您使用自己的训练脚本为自定义模型，并在为流行框架预构建的容器上运行它们。这被称为脚本模式。对于未覆盖的预构建容器框架，您也可以使用自己的容器为几乎任何您选择的框架。

让我们以用 TensorFlow 编写的情感分析模型为例，向您展示如何在 SageMaker 中使用自己的脚本运行 SageMaker 预构建的 TensorFlow 容器。然后我们将描述其他框架的类似过程。

TensorFlow

TensorFlow 是一个开源的机器学习框架，专门用于深度神经网络。您可以使用 SageMaker 预构建的 TensorFlow 训练和推理容器运行 TensorFlow 代码，这些容器通过 SageMaker SDK 的sagemaker.tensorflow提供。请使用ml.t3.medium实例打开存储库中的chapter05/02-tensorflow_sentiment_analysis.ipynb笔记本。在这个例子中，目标是使用 TensorFlow 层构建的神经网络从 IMDb 电影数据库中的电影评论中训练和预测情感（正面/负面）。您可以在笔记本中运行神经网络训练，但这将需要您始终拥有一个能够训练大量数据的深度神经网络的计算实例，即使您只是在探索数据和编写代码时也是如此。但是，使用 SageMaker，您可以通过使用较小的实例进行代码构建，仅使用 GPU 实例进行大规模训练来优化计算使用。

在chapter06/02-tensorflow_sentiment_analysis.ipynb中，我们首先安装所需的库并设置 Sagemaker 会话。然后，我们从tensorflow.python.keras.datasets加载 IMDb 数据集，进行最小数据预处理，并将训练和测试分割保存到本地文件系统，然后保存到 S3 桶中。

假设我们之前已经开发了一个适用于此 IMDb 数据集的神经网络架构，如下面的代码块所示，我们可以轻松地将它带入 SageMaker 进行训练。

embedding_layer = tf.keras.layers.Embedding(max_features,
                                            embedding_dims,
                                            input_length=maxlen)
sequence_input = tf.keras.Input(shape=(maxlen,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
x = tf.keras.layers.Dropout(args.drop_out_rate)(embedded_sequences)
x = tf.keras.layers.Conv1D(filters, kernel_size, padding='valid', activation='relu', strides=1)(x)
x = tf.keras.layers.MaxPooling1D()(x)
x = tf.keras.layers.GlobalMaxPooling1D()(x)
x = tf.keras.layers.Dense(hidden_dims, activation='relu')(x)
x = tf.keras.layers.Dropout(drop_out_rate)(x)
preds = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model(sequence_input, preds)
optimizer = tf.keras.optimizers.Adam(learning_rate)
model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])

SageMaker 可以将 TensorFlow 脚本放入 Docker 容器中，并使用数据训练脚本。为此，SageMaker 需要脚本了解容器中设置的环境变量、计算基础设施，并且可选地，脚本需要能够从执行中获取输入，例如超参数。以下是步骤：

1. 创建一个脚本，用于输入模型架构和数据加载函数（get_model、get_train_data、get_test_data等）。

2. 创建一个参数解析器，从脚本执行中获取参数，例如超参数和训练数据位置。SageMaker 将作为容器中的可执行文件运行脚本，并通过 SDK 调用指定参数。训练数据位置通过容器中 SageMaker 设置的环境变量（SM_CHANNEL_*）传递给脚本。参数解析器在parse_arg()函数中定义，如下所示：

   def parse_args():
       parser = argparse.ArgumentParser()
       # hyperparameters sent by the client are passed as command-line arguments to the script
       parser.add_argument('--epochs', type=int, default=1)
       parser.add_argument('--batch_size', type=int, default=64)
       parser.add_argument('--learning_rate', type=float, default=0.01)
       parser.add_argument('--drop_out_rate', type=float, default=0.2)
       # data directories
       parser.add_argument('--train', type=str, default=os.environ.get('SM_CHANNEL_TRAIN'))
       parser.add_argument('--test', type=str, default=os.environ.get('SM_CHANNEL_TEST'))
       # model directory /opt/ml/model default set by SageMaker
       parser.add_argument('--model_dir', type=str, default=os.environ.get('SM_MODEL_DIR'))
       return parser.parse_known_args()
   

   注意

   SM_CHANNEL_*环境变量中的TRAIN或TEST后缀必须与estimator.fit()调用中输入数据通道提供的字典键匹配。因此，当我们指定数据通道时，我们需要创建一个键为TRAIN和TEST的字典，不区分大小写。

3. 将训练步骤作为if __name__ == "__main__":部分的一部分：

   if __name__ == "__main__":
       args, _ = parse_args()
       x_train, y_train = get_train_data(args.train)
       x_test, y_test = get_test_data(args.test)
       model = get_model(args)
       history = model.fit(x_train, y_train,
                 batch_size=args.batch_size,
                 epochs=args.epochs,
                 validation_data=(x_test, y_test))
       save_history(args.model_dir + "/history.p", history)
       # create a TensorFlow SavedModel for deployment to a SageMaker endpoint with TensorFlow Serving
       model.save(args.model_dir + '/1')
   

4. 确保将网络中的变量替换为从参数解析器中获取的变量。例如，将tf.keras.optimizers.Adam(learning_rate)更改为tf.keras.optimizers.Adam(args.learning_rate)。

5. 在我们的笔记本中，我们将脚本写入到code/tensorflow_sentiment.py。

6. 使用sagemaker.tensorflow.TensorFlow创建一个 TensorFlow 估计器，它是我们之前用于专门与 TensorFlow 编写的 ML 训练一起使用的estimator类的扩展：

   from sagemaker.tensorflow import TensorFlow
   exp_datetime = strftime('%Y-%m-%d-%H-%M-%S', gmtime())
   jobname = f'imdb-tf-{exp_datetime}'
   model_dir = f's3://{bucket}/{prefix}/{jobname}'
   code_dir = f's3://{bucket}/{prefix}/{jobname}'
   train_instance_type = 'ml.p3.2xlarge'
   hyperparameters = {'epochs': 10, 'batch_size': 256, 'learning_rate': 0.01 , 'drop_out_rate': 0.2 }
   estimator = TensorFlow(source_dir='code',
                          entry_point='tensorflow_sentiment.py',
                          model_dir=model_dir,
                          code_location=code_dir,
                          instance_type=train_instance_type,
                          instance_count=1,
                          enable_sagemaker_metrics=True,
                          hyperparameters=hyperparameters,
                          role=role,
                          framework_version='2.1',
                          py_version='py3')
   

在 TensorFlow 估计器中，一些关键的参数包括source_dir、entry_point、code_location、framework_version和py_version。source_dir和entry_point是我们指定训练脚本在 EFS 文件系统上的位置（code/tensorflow_sentiment.py）。如果您需要使用任何额外的 Python 库，可以将库包含在一个requirements.txt文件中，并将该文本文件放置在source_dir参数指定的目录中。SageMaker 将首先安装requirements.txt中列出的库，然后再执行训练脚本。code_location是脚本将在 S3 上放置的位置。framework_version和py_version允许我们指定训练脚本开发的 TensorFlow 版本和 Python 版本。

注意

您可以在github.com/aws/deep-learning-containers/blob/master/available_images.md找到支持的 TensorFlow 版本。您可以在sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html找到 TensorFlow 估计器 API。

1. 创建数据通道字典：

   data_channels = {'train':train_s3, 'test': test_s3}
   

2. 在 SageMaker Experiments 中创建一个新的实验：

   experiment_name = 'imdb-sentiment-analysis'
   try:
       experiment = Experiment.create(
           experiment_name=experiment_name, 
           description='Training a sentiment classification model using imdb dataset.')
   except ClientError as e:
       print(f'{experiment_name} experiment already exists! Reusing the existing experiment.')
   # Creating a new trial for the experiment
   exp_trial = Trial.create(
       experiment_name=experiment_name, 
       trial_name=jobname)
   experiment_config={
       'ExperimentName': experiment_name,
       'TrialName': exp_trial.trial_name,
       'TrialComponentDisplayName': 'Training'}
   

3. 使用数据和实验配置调用estimator.fit()函数：

   estimator.fit(inputs=data_channels,
                 job_name=jobname,
                 experiment_config=experiment_config,
                 logs=True)
   

在一个配备一个高性能 NVIDIA® V100 Tensor Core GPU 的 ml.p3.2xlarge 实例上进行的训练大约需要 3 分钟。一旦训练作业完成，您可以从 S3 上的model_dir访问训练好的模型。这个模型是一个 Keras 模型，可以通过 Keras 的load_model API 加载。然后，您可以以与在 TensorFlow 中相同的方式评估模型：

!mkdir ./imdb_data/model -p
!aws s3 cp {estimator.model_data} ./imdb_data/model.tar.gz
!tar -xzf ./imdb_data/model.tar.gz -C ./imdb_data/model/
my_model=tf.keras.models.load_model('./imdb_data/model/1/')
my_model.summary()
loss, acc=my_model.evaluate(x_test, y_test, verbose=2)
print('Restored model, accuracy: {:5.2f}%'.format(100 * acc))
782/782 - 55s - loss: 0.7448 - accuracy: 0.8713
Restored model, accuracy: 87.13%

我们已经成功使用 SageMaker 的全托管训练基础设施训练了一个自定义 TensorFlow 模型来预测 IMDb 评论的情感。对于其他框架，采用自定义脚本的 SageMaker 过程相当类似。我们将查看 PyTorch、Hugging Face、MXNet 和 scikit-learn 的估计器 API，它们共享相同的基类：sagemaker.estimator.Framework。

PyTorch

PyTorch 是一个流行的开源深度学习框架，与 TensorFlow 类似。类似于 SageMaker 支持 TensorFlow，SageMaker 也有一个针对 PyTorch 的估计器。您可以使用 sagemaker.pytorch.PyTorch 类访问它。该 API 的文档可在 sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html 查阅。按照 步骤 1-9 在 TensorFlow 部分说明使用您的 PyTorch 训练脚本，但需要指定 PyTorch 版本以访问特定的 SageMaker 管理的 PyTorch 训练容器镜像。

Hugging Face

Hugging Face 是一个专注于自然语言处理用例的机器学习框架。它帮助您通过预构建的架构和预训练模型轻松训练复杂的 NLP 模型。它与 TensorFlow 和 PyTorch 都兼容，因此您可以使用您最熟悉的框架进行训练。您可以使用 sagemaker.huggingface.HuggingFace 类访问估计器。该 API 的文档可在 sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html 查阅。按照 步骤 1-9 在 TensorFlow 部分说明使用您的脚本。与 TensorFlow/PyTorch 估计器相比，主要区别是有一个额外的参数 transformers_version，用于 pytorch_version 或 tensorflow_version，而不是 framework_version。

MXNet

MXNet 是一个流行的开源深度学习框架，与 TensorFlow 类似。您可以使用 sagemaker.mxnet.MXNet 类访问 MXNet 估计器。API 文档可在 sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html 查阅。按照 步骤 1-9 在 TensorFlow 部分说明使用您的 MXNet 训练脚本，但需要指定 MXNet 版本以访问特定的 SageMaker 管理的容器镜像。

Scikit-learn

sagemaker.sklearn.SKLearn 类。该 API 的文档可在 https://sagemaker.readthedocs.io/en/stable/frameworks/sklearn/sagemaker.sklearn.html 查阅。按照 步骤 1-9 在 TensorFlow 部分说明使用您的 sklearn 训练脚本，但需要指定 sklearn 版本以访问特定的 SageMaker 管理的容器镜像，而不是使用 framework_version。

在 SageMaker Studio 中开发时，您通常需要能够与同事协作，并能够使用各种 Python 库运行机器学习和数据科学代码。让我们看看我们如何在 SageMaker Studio 中丰富我们的模型构建体验。

使用 SageMaker Notebook 进行开发和协作

SageMaker Studio IDE 使协作和定制变得容易。除了可以选择支持 SageMaker 笔记本的内核和实例之外，您还可以管理 Git 仓库、比较笔记本和共享笔记本。

用户可以在 SageMaker Studio 中轻松地与 Git 仓库进行交互，您可能已经为此书从 GitHub 克隆了示例仓库。您不仅可以从系统终端克隆仓库，还可以使用 UI 左侧栏中的 Git 集成以图形方式与您的代码库进行交互，如图 图 5.4 所示。您可以使用 UI 执行您通常在 Git 中执行的操作：切换分支、拉取、提交和推送。

![图 5.4 – SageMaker Studio IDE 中 Git 集成的图形界面

![图片 B17447_06_04.jpg]

图 5.4 – SageMaker Studio IDE 中 Git 集成的图形界面

您也可以通过在更改的文件上右键单击并选择 $ git diff 来对更改的文件执行 notebook diff。例如，在 图 5.5 中，我们可以清楚地看到 instance_type 自上次提交以来已经发生了变化：

![图 5.5 – 在 Git 中可视化笔记本中的更改

![图片 B17447_06_05.jpg]

图 5.5 – 在 Git 中可视化笔记本中的更改

SageMaker Studio 中的另一个强大协作功能是与您的同事共享笔记本，以便他们可以直接在您创建的笔记本上工作。您可以通过笔记本右上角的 分享 按钮轻松地与输出和 Git 仓库信息共享笔记本，如图 图 5.6 所示：

![图 5.6 – 在 SageMaker Studio 中与另一用户共享笔记本

![图片 B17447_06_06.jpg]

图 5.6 – 在 SageMaker Studio 中与另一用户共享笔记本

您将被提示选择要包含的信息级别，并将提供一个类似 https://.studio..sagemaker.aws/jupyter/default/lab?sagemaker-share-id=xxxxxxxxxxxxxxxxxxx 的 URL，任何人只要在相同的 SageMaker Studio 域中有用户配置文件，就可以访问。一旦您的同事打开此 URL，他们将看到只读笔记本、快照详情以及创建副本以便编辑笔记本的选项，如图 图 5.7 所示：

![图 5.7 – 共享笔记本的另一个用户的视图

![图片 B17447_06_07.jpg]

图 5.7 – 共享笔记本的另一个用户的视图

注意

当创建域时，笔记本共享功能需要配置。如果您使用 快速入门 设置域，如 第二章 中所述，介绍 Amazon SageMaker Studio，则笔记本共享被启用。如果您使用标准设置，则需要明确启用笔记本共享。

摘要

在本章中，我们解释了您如何在 SageMaker Studio 的笔记本中训练机器学习模型。我们运行了两个示例，一个示例使用 SageMaker 内置的 BlazingText 算法来训练文本分类模型，另一个示例使用 TensorFlow 作为深度学习框架来构建网络架构，以训练情感分析模型来预测电影评论数据中的情感。我们学习了 SageMaker 的完全托管训练功能是如何工作的，以及如何从 SageMaker SDK 为您的训练脚本配置正确的计算资源。

我们展示了 SageMaker Experiments 在 SageMaker Studio 的 UI 中管理并比较机器学习训练运行的能力。除了使用 TensorFlow 脚本进行训练外，我们还解释了 SageMaker 在处理各种机器学习框架（如 PyTorch、MXNet、Hugging Face 和 scikit-learn）时的灵活性。最后但同样重要的是，我们向您展示了 SageMaker 的 Git 集成和笔记本共享功能如何帮助提高您的生产力。

在下一章中，我们将学习关于SageMaker Clarify以及如何将 SageMaker Clarify 应用于检测数据集和机器学习模型中的偏差，并解释模型是如何做出决策的。理解偏差和模型可解释性对于创建公平的机器学习模型至关重要。我们将深入探讨 SageMaker Clarify 使用的测量偏差的方法、指标，以及 Clarify 如何解释模型。

第六章：使用 SageMaker Clarify 检测 ML 偏差和解释模型

机器学习（ML）模型正越来越多地被用于帮助各行各业做出商业决策，例如在金融服务、医疗保健、教育和人力资源（HR）等领域，这得益于 ML 提供的自动化，其准确性超过了人类。然而，ML 模型从不完美。它们可能会做出糟糕的决策——如果不仔细训练和评估，甚至可能是不公平的决策。ML 模型可能会以伤害弱势群体的方式产生偏差。在 ML 生命周期中能够理解数据和 ML 模型中的偏差对于创建一个社会公平的 ML 模型至关重要。SageMaker Clarify 在数据集和 ML 模型中计算 ML 偏差，以帮助您了解 ML 模型的局限性，从而您可以采取适当的行动来减轻这些偏差。

ML 模型长期以来一直被视为黑盒操作，因为很难看到预测是如何做出的。SageMaker Clarify 通过计算特征归因来帮助您解释 ML 模型是如何做出决策的，这样它就不再是我们的黑盒了。SageMaker Clarify 与 SageMaker Studio 集成，以便您在构建 ML 模型时可以轻松地审查结果。使用 SageMaker Clarify，您将能够更多地了解您的 ML 模型，提高您在 ML 用例中的公平性和可解释性，并在需要时满足监管要求。

在本章中，我们将学习以下主题：

• 理解 ML 中的偏差、公平性和 ML 可解释性

• 检测 ML 中的偏差

• 使用 SHapley Additive exPlanations （SHAP）值解释 ML 模型

技术要求

对于本章，您需要访问提供的代码，请参阅github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter06。

理解 ML 中的偏差、公平性和 ML 可解释性

在机器学习中，我们可以分析和缓解两种类型的偏差以确保公平性——数据偏差和模型偏差。数据偏差是指在不同群体和类别之间训练数据的不平衡，这可能是由于采样错误简单地引入到机器学习解决方案中，或者由于不幸地根植于社会中的固有原因而复杂地引入。如果忽视数据偏差，可能会在训练模型中对某个群体产生不公平的预测，并导致整体准确率下降。能够尽早发现数据中的固有偏差并采取措施解决它们比以往任何时候都更加关键。另一方面，模型偏差是指由模型预测引入的偏差，例如分类和错误在优势群体和劣势群体之间的分布。如果模型在特定结果上偏向优势群体，或者不成比例地错误预测劣势群体，导致在现实世界的机器学习应用（如贷款批准预测系统）中产生不良后果，我们作为数据科学家需要采取措施来了解为什么会发生这种情况并缓解这种行为。

确保机器学习中的公平性始于理解数据并检测其中的偏差。数据偏差可能导致模型偏差，因为众所周知，模型将学习数据中呈现的内容，包括任何偏差，并将其在推理中复制。使用由机器学习社区开发和接受的指标来量化偏差对于检测和选择缓解方法至关重要。

能够解释模型如何做出决策是确保机器学习模型公平性的另一个关键因素。人们长期以来认为机器学习是一个神秘的黑盒——它预测事物比人类更好，但没有人知道为什么或如何。但是，机器学习研究人员已经开发了框架来帮助打开这个黑盒，其中最著名的一个是 SHAP。SHAP 计算并为特定预测的每个特征分配一个重要性分数。这个重要性分数被称为Shapley 值，它是合作博弈论的一种实现，用于在模型的输入特征之间分配模型输出的信用。对于预测中每个特征的 Shapley 值，我们可以描述模型如何以及为什么做出这样的预测，以及哪个特征对此贡献最大。如果存在对模型预测有显著贡献的敏感特征，我们需要采取措施来解决这个问题的影响。

Amazon SageMaker Clarify 帮助开发者发现训练数据和模型预测中的潜在偏差，并为机器学习模型解释特征重要性。SageMaker Clarify 计算各种指标来衡量数据中的偏差，这样你就不必成为机器学习偏差科学的专家。你可以使用 SageMaker Clarify 与 SageMaker 软件开发工具包 (SDK) 结合，从笔记本中分析数据和模型，这是我们本章将重点关注的。SageMaker Clarify 还与 Amazon SageMaker Data Wrangler 集成，这样你可以使用简单的图形界面检测偏差。SageMaker Clarify 还进一步与 Amazon SageMaker Experiments 集成，为每个实验提供图形结果，并与 Amazon SageMaker Model Monitor 集成，这样你可以在训练模型和在生产中的推理数据中识别偏差和特征重要性。

让我们从机器学习的一个例子开始，看看我们如何使用 SageMaker Clarify 来检测偏差。

检测机器学习中的偏差

对于本章，我想使用来自 加州大学欧文分校 （UCI） 机器学习存储库的机器学习成人人口普查收入数据集（archive.ics.uci.edu/ml/datasets/adult）。这个数据集包含来自人口普查数据的人口统计信息以及作为预测目标的收入水平。数据集的目标是根据人口普查信息预测一个人是否每年收入超过或低于 美元 （USD） $50,000 （$50K）。这是一个很好的例子，并且是包含如性别和种族等社会敏感类别的机器学习用例，在生成机器学习模型时受到最严格的审查和监管，以确保公平性。

在本节中，我们将分析数据集以检测训练数据中的数据偏差，如果存在任何偏差，我们将减轻它，训练一个机器学习模型，并分析是否存在针对特定群体的模型偏差。

检测预训练偏差

请打开笔记本 在 Amazon SageMaker Studio 中入门``/chapter06/01-ml_fairness_clarify.ipynb 并按照以下步骤操作：

1. 我们将使用 SageMaker Experiments 来组织分析和训练工作。因此，我们在第一个单元中安装 sagemaker-experiments，并在接下来的两个单元中设置 SageMaker 会话并导入所需的库。

2. 在第四个单元格中，我们从 UCI ML 仓库加载训练和测试数据集。orig_columns值是从archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.names解析出来的。原始数据集在education和education-num特征中既有字符串表示也有序数表示的教育水平。我们只保留序数表示并删除education列。我们还把target列移到第一列，因为我们将会使用 SageMaker 的内置XGBoost算法来训练一个机器学习模型以预测目标。target列包含收入大于$50K（>50K）和小于等于$50K（<=50K）的标签。你可以在以下截图看到这个说明：

图 6.1 – 第 2 步后的 DataFrame 截图

1. 我们使用sklearn中的OrdinalEncoder将训练数据（df）和测试数据（df_valtest）中的分类特征进行编码，以便使数据集与 XGBoost 算法兼容。编码后，值大于50K和小于等于50K的target变量分别编码为1和0；存在一个可能敏感的sex类别，其中Male和Female值分别编码为1和0。我们进一步将测试数据集的 10%作为验证数据集用于模型训练。

2. 使用这个数据集，我们可以从许多角度分析数据以寻找偏差和公平性。直观上，收入中的性别平等可能是一个我们可以从其开始的视角。让我们进行一些可视化来定性理解它，如下所示：

   df['sex'].value_counts(sort=False).plot(kind='bar', title='Total count by sex', rot=0)
   plt.xlabel('Sex (0: Female, 1: Male)')
   df['target'].value_counts(sort=False).plot(kind='bar', title='Target distribution', rot=0)
   plt.xlabel('target (0: <=50K, 1: >50K)')
   df[df['target']==1]['sex'].value_counts(sort=False).plot(kind='bar', title='Earning >$50K by sex', rot=0)
   plt.xlabel('Sex (0: Female, 1: Male)')
   

在下一张截图，我们可以观察到以下内容：

• 女性的总数大约是男性的半数。

• 有更多的人的收入低于$50K。

• 在收入超过$50K 的人群中，男性比女性多。

你可以在这里看到输出：

图 6.2 – 绘图输出，显示性别和收入水平的分布；在性别和收入水平上可以观察到不平衡的分布

这种分布可能反映了社会不平等，但我们如何量化这些偏斜的分布，以便我们可以自动和程序化地更了解数据集中的偏差？这正是 SageMaker Clarify 发挥作用的地方。

SageMaker Clarify 来自 SageMaker SDK（sagemaker.clarify）使用专用容器和 SageMaker Processing 来计算机器学习偏差和解释机器学习预测。我们可以通过以下方式实例化sagemaker.clarify.SageMakerClarifyProcessor，选择适合数据集的计算资源类型：

from sagemaker import clarify
clarify_processor = clarify.SageMakerClarifyProcessor(
         role=role, 
         instance_count=1, 
         instance_type='ml.m5.xlarge', 
         sagemaker_session=sess)

1. 我们将专门使用SageMakerClarifyProcessor.run_pre_training_bias()来计算在训练 ML 模型之前的数据偏见。它返回的指标允许我们根据我们选择的目标和方面量化数据偏见，并允许我们采取措施减轻偏见。但是，首先run_pre_training_bias()需要两个配置：一个clarify.DataConfig()，如下面的代码块所示：

   pretraining_bias_report_output_path = f's3://{bucket}/{prefix}/{experiment_name}-{exp_trial_1.trial_name}/clarify-pretraining-bias'
   bias_data_config = clarify.DataConfig(
       s3_data_input_path=train_s3_uri,
       s3_output_path=pretraining_bias_report_output_path,
       label='target',
       headers=df.columns.tolist(),
       dataset_type='text/csv')
   

因为train_s3_uri中的训练数据不包含列标题，所以特征列通过headers参数提供。在label参数中，我们指定数据集中的目标变量，它必须是headers参数中输入的列名之一。

在偏见配置中，我们指定方面——即我们希望使用clarify.BiasConfig()分析的敏感类别，如下所示：

bias_config = clarify.BiasConfig(
    label_values_or_threshold=[1], 
    facet_name=['sex', 'race'], 
    facet_values_or_threshold=[[0], None])

我们希望分析数据集中存在多少性别偏见（sex列），特别是结果（target列）如何受到性别的影响。为此，我们从目标中指定一个正类（>50K或1）到label_values_or_threshold参数的列表中。我们指定要分析的方面为sex和race。尽管在这个例子中我们主要关注性别偏见，但我们添加了一个race特征来展示您可以使用多个特征作为方面，并且 SageMaker Clarify 会同时分析所有方面的偏见。最后一个必需的参数facet_values_or_threshold用于指定 SageMaker Clarify 在量化偏见时关注的敏感类别。facet_values_or_threshold=[[0], None]对应于facet_name=['sex', 'race']。这意味着我们要求 Clarify 只计算sex中类0的偏见指标，即女性，而对于race没有指定一个类（None），这将迫使 Clarify 计算race中所有类的偏见指标。

1. 一旦设置完成，我们可以使用配置运行处理作业，如下所示：

   clarify_processor.run_pre_training_bias(
       data_config=bias_data_config,
       data_bias_config=bias_config,
       methods='all',
       job_name=jobname,
       experiment_config=experiment_config)
   

我们要求 Clarify 计算所有可能的预训练偏见，使用methods='all'。SageMaker Clarify 与 SageMaker Experiments 集成，因此我们为此作业提供了实验和试验配置。在笔记本中，我们命名实验为experiment_name = 'adult-income-clarify'。

1. 我们可以在adult-income-clarify条目中可视化 Clarify 结果，并右键单击名为时间戳的新试验条目以选择在试验组件列表中打开，如下面的截图所示：

![图 6.3 – 选择试验以查看 SageMaker Clarify 结果

![图片/B17447_04_03.jpg]

图 6.3 – 选择试验以查看 SageMaker Clarify 结果

在主工作区域将显示一个包含试验组件列表的新页面。我们可以通过右键单击条目并选择在试验详情中打开来打开试验详情页面查看结果，如下面的截图所示：

![图 6.4 – 选择试验组件以查看 SageMaker Clarify 结果

图 6.4 – 选择试验组件以查看 SageMaker Clarify 结果

1. 在试验组件页面，切换到偏差报告选项卡以找到分析结果，如下面的截图所示。在这里，您可以找到 SageMaker Clarify 计算的指标：

![图 6.5 – 在 SageMaker Studio 的试验详情页上审查预训练偏差报告

图 6.5 – 在 SageMaker Studio 的试验详情页上审查预训练偏差报告

对于每个指标，您都可以看到一个描述来了解它的含义。如需更多信息，您可以展开一项内容以了解指标是如何计算的，包括示例和解释。此外，您可以在详细描述中找到更多关于所有指标数学定义的论文。

备注

为了方便起见，此统一资源定位符（URL）将带您到技术白皮书：pages.awscloud.com/rs/112-TZM-766/images/Amazon.AI.Fairness.and.Explainability.Whitepaper.pdf。如果您对指标背后的数学感兴趣，这是一份很好的阅读材料。

让我们回顾数据中的偏差。最值得注意的是，报告指出存在sex特征（因为女性比男性少 0.34 或 34%），在>50K方面，男性比女性多 0.2 或 20%。在数据集中，收入超过 50K 的男性比女性多，这两个指标单独不仅证实了我们之前在笔记本中绘制的图表中看到的失衡，而且量化了这种失衡。

备注

对于clarify.BiasConfig(group_name=None)没有有效的结果。

您可以通过切换分析偏差的列和分析偏差的列值或阈值下拉列表来查看clarify.BiasConfig()中指定的其他方面和类别（例如，race）的分析——通过切换分析偏差的列和分析偏差的列值或阈值下拉列表。

SageMaker Clarify 还会在pretraining_bias_report_output_path变量中保存分析副本。

如果不缓解这种数据失衡，它很可能在训练后嵌入到 ML 模型中，并开始重复从偏差数据中学到的内容。让我们看看如何缓解它。

缓解偏差和训练模型

有几种数据科学方法可以缓解数据不平衡，例如匹配、过采样和欠采样。在这个例子中，让我们尝试基于性别和目标结果进行简单的匹配，以平衡男性和女性样本以及正结果（>50K）的比例。我们将按以下步骤进行：

1. 回到笔记本，我们继续使用数据来处理偏差，如下所示：

   max_female_sample=df.groupby(['sex', 'target'], 
              group_keys=False).count().loc[(0, 1)]['age']
   df_sampled=df.groupby(['sex', 'target'], 
   group_keys=False).apply(lambda x: x.sample(max_female_sample))
   

这生成了一个具有相等性别数量和相等目标结果比例的采样和匹配数据集。

1. 我们可以通过绘制相同的图表并使用 SageMaker Clarify 对此样本和匹配的数据集创建另一个预训练偏差分析来验证这种方法的有效性。请注意，我们正在 SageMaker Experiments 中创建另一个试验来跟踪此运行并将输出直接发送到不同的输出 S3 位置。以下代码片段展示了这个过程：

   pretraining_bias_report_output_path = f's3://{bucket}/{prefix}/{experiment_name}-{exp_trial_2.trial_name}/clarify-pretraining-bias'
   bias_data_config = clarify.DataConfig(
       s3_data_input_path=train_sampled_s3_uri,
       s3_output_path=pretraining_bias_report_output_path,
       label='target',
       headers=df_sampled.columns.tolist(),
       dataset_type='text/csv')
   

然后，我们使用相同的 bias_config 并调用之前使用的 clarify_processor.run_pre_training_bias() 方法来在偏差缓解后运行预训练偏差分析作业。

1. SageMaker Clarify 作业完成后，我们可以在新预训练偏差分析作业的试验详情页上打开偏差报告功能。您可以看到，类别不平衡（CI）和标签中正例比例差异（DPL）现在都是零。实际上，所有偏差指标都是零。

2. 我们已经成功消除了之前观察到的数据偏差。让我们使用 SageMaker 内置的 XGBoost 算法开始模型训练，这是一个非常适合我们这种结构化数据的优秀工具。我们将此训练作业作为第二个试验 exp_trial_2 中的新试验组件运行。对于超参数，我们选择二分类的 binary:logistic 目标，error 作为评估指标，以及 50 轮优化。以下代码片段展示了这个过程：

   experiment_config={'ExperimentName': experiment_name,
                      'TrialName': exp_trial_2.trial_name,
                      'TrialComponentDisplayName': 'Training'}
   ...
   xgb = sagemaker.estimator.Estimator(
           image,
           role,
           instance_type='ml.m5.xlarge',
           instance_count=1,
           output_path=train_s3_output,
           enable_sagemaker_metrics=True,
           sagemaker_session=sess)
   xgb.set_hyperparameters(objective='binary:logistic',
                           eval_metric='error',
                           num_round=50)
   ...
   data_channels={'train': train_input, 'validation': val_input}
   xgb.fit(inputs=data_channels, 
           job_name=jobname, 
           experiment_config=experiment_config, 
           wait=True)
   

训练作业包括基础设施配置，大约需要 5 分钟。

1. 我们从训练作业中创建一个 SageMaker 模型，以便以后可以在 SageMaker Clarify 作业中使用它来分析模型偏差。以下是执行此操作的代码：

   model = xgb.create_model(name=model_name)
   container_def = model.prepare_container_def()
   sess.create_model(model_name, role, container_def)
   

模型训练完成后，我们可以使用 SageMaker Clarify 来检测和测量预测中出现的偏差。

检测训练后偏差

以下步骤分析模型训练后的预测和数据的偏差。要使用 SageMaker Clarify 运行训练后的偏差分析，我们需要准备三个配置：一个数据配置、一个偏差配置和一个模型配置。按照以下步骤进行：

1. 创建一个新的 clarify.DataConfig() 实例来分析匹配的训练数据，并将输出直接发送到不同的输出 S3 位置，如下所示：

   posttraining_bias_report_output_path = f's3://{bucket}/{prefix}/{experiment_name}-{exp_trial_2.trial_name}/clarify-posttraining-bias' 
   bias_data_config = clarify.DataConfig(
       s3_data_input_path=train_sampled_s3_uri,
       s3_output_path=posttraining_bias_report_output_path,
       label='target',
       headers=df_sampled.columns.tolist(),
       dataset_type='text/csv')
   

2. 偏差配置与我们在预训练偏差分析中使用的配置相同。我们继续分析模型预测如何受到 sex、race 和 target 分布的影响。

3. 当开始训练后分析作业时，会创建一个 SageMaker 实时端点，带有 ML 模型，用于在短时间内对输入数据进行预测，以避免对生产端点产生额外的流量（如果有的话）。此端点也称为影子端点，一旦分析作业完成，将取消配置。对于模型配置，我们指定一个模型并配置端点。accept_type 表示端点响应的有效负载格式，而 content_type 表示对端点的请求的有效负载格式。

我们还指定了 0.5 的概率阈值，将 XGBoost 模型的概率输出转换为二进制硬标签，如下所示：

model_config = clarify.ModelConfig(
    model_name=model_name,
    instance_type='ml.m5.xlarge',
    instance_count=1,
    accept_type='text/csv',
    content_type='text/csv')
predictions_config = clarify.ModelPredictedLabelConfig(probability_threshold=0.5)

预测值大于 0.5 的被预测为 1 (>50K)；否则，为 0 (<=50K)。

1. 最后，我们使用配置运行作业。我们请求计算所有有效的训练后偏差指标，如下所示：

   clarify_processor.run_post_training_bias(
       data_config=bias_data_config,
       data_bias_config=bias_config,
       model_config=model_config,
       model_predicted_label_config=predictions_config,
       methods='all',    
       job_name=jobname,
       experiment_config=experiment_config)
   

2. 我们还可以在第二个试验的试验详情页上查看结果 (exp_trial_2.trial_name)，如下所示截图。与预训练偏差分析相比，我们看到显示的指标集不同。训练后偏差作业专注于分析预测标签或比较预测与数据中具有不同属性组的观察到的目标值：

图 6.6 – 在 SageMaker Studio 的试验详情页上查看训练后偏差报告

大多数指标，如 准确度差异 (AD)，偏差非常低，这意味着模型在预测男女收入水平时具有相同的准确性。然而，有一个指标具有相当高的偏差：处理平等 (TE)。这衡量的是 Type 1 错误（假阳性）和 Type 2 错误（假阴性）是否以相同的方式影响两个性别。这是男性和女性组中假阴性与假阳性的比率差异。正值表示女性具有更低的假阴性与假阳性比率。这意味着模型更频繁地错误地将女性预测为高收入者，而实际上她们并不是；相反，情况正好相反。与男性相比，女性的假阳性率更高，这可能会引起一些担忧，并可能导致模型产生不公平的后果。

注意

在 检测预训练偏差 部分中分享的技术白皮书也包含了许多关于训练后指标的更多细节。您可以在以下链接找到该论文：pages.awscloud.com/rs/112-TZM-766/images/Amazon.AI.Fairness.and.Explainability.Whitepaper.pdf。

在理解了如何测量偏差，包括预训练和训练后，我们还应该探索 ML 模型是如何像使用 SageMaker Clarify 那样做出决策的。

使用 SHAP 值解释 ML 模型

SageMaker Clarify 还根据 Shapley 值的概念计算模型无关的特征归因。Shapley 值可以用来确定每个特征对模型预测的贡献。特征归因有助于解释模型是如何做出决策的。拥有一种可量化的方法来描述模型是如何做出决策的，使我们能够信任满足监管要求并支持人类决策过程的 ML 模型。

与使用 SageMaker Clarify 设置运行偏差分析作业的配置类似，设置模型可解释性作业需要三个配置：一个数据配置、一个模型配置和一个可解释性配置。让我们按照以下步骤从同一个笔记本开始：

1. 使用训练数据集（匹配）创建一个数据配置。这与我们之前创建的数据配置类似。以下代码片段展示了代码：

   explainability_data_config = clarify.DataConfig(
       s3_data_input_path=train_sampled_s3_uri,
       s3_output_path=explainability_output_path,
       label='target',
       headers=df_sampled.columns.tolist(),
       dataset_type='text/csv')
   

2. 创建或重用之前为训练后偏差分析作业创建的 model_config 参数。

3. 创建一个带有基线的 clarify.SHAPConfig() 实例。基线是一个数据点的实例，将用于与输入数据一起计算 Shapley 值。对于相同的模型，你可以预期根据不同的基线得到不同的解释，因此基线的选择至关重要。选择一个具有非常低信息含量的通用基线是可取的，例如平均值或中值特征向量。在这种情况下，在我们的示例中，我们将解释模型归因为什么预测某个人为高收入者，而不是一个普通人。或者，你也可以选择根据特定类型的数据来解释模型。例如，我们可以从代表推理中人群的类似人口中选择基线。以下代码片段展示了代码：

   baseline = df_sampled.query('target == 1').mode().iloc[0, 1:].astype(int).tolist()
   shap_config = clarify.SHAPConfig(
       baseline=[baseline],
       num_samples=15,
       agg_method='mean_abs')
   

在我们的示例中，让我们使用 mode 为基线模拟训练数据中的一个“平均”高收入（>50K）的人。num_samples 参数用于确定生成合成数据集的大小以计算 SHAP 值。你也可以留空，让 Clarify 自动选择一个数字。agg_method='mean_abs' 表示如何聚合全局 SHAP 值。

1. 之后，我们使用配置开始分析作业，如下所示：

   clarify_processor.run_explainability(
       data_config=explainability_data_config,
       model_config=model_config,
       explainability_config=shap_config,
       job_name=jobname,
       experiment_config=experiment_config,
       wait=False,
       logs=False)
   

2. 一旦处理作业完成，我们可以在 SageMaker Experiments 下的 education-num 特征的试验详情页上查看结果，该特征代表最高的教育水平，对预测收入水平（>50K 或 <=50K）的贡献最大：

![图 6.7 – 在 SageMaker Studio 中查看模型可解释性结果 SHAP 值]

![img/B17447_04_07.jpg]

图 6.7 – 在 SageMaker Studio 中查看模型可解释性结果（SHAP 值）

1. 除了全局 SHAP 值之外，我们还可以审查任何给定数据点的局部 SHAP 解释，以解释模型是如何针对这个特定数据点进行预测的。SageMaker Clarify 计算并保存整个数据集的局部解释，该数据集在clarify.DataConfig()中提供，并在explainability_output_path中保存。我们可以使用以下代码绘制特定数据点（第 500 行）的每个特征的局部 SHAP 值：

   S3Downloader.download(f'{explainability_output_path}/explanations_shap/out.csv', './', sagemaker_session=sess)
   local_explanations_out = pd.read_csv('out.csv')
   feature_names = [str.replace(c, '_label0', '') for c in local_explanations_out.columns.to_series()]
   local_explanations_out.columns = feature_names
   selected_example = 500
   print(f'Example number: {selected_example}')
   print(f'with model prediction: {sum(local_explanations_out.iloc[selected_example]) > 0}')
   print()
   print(f'Feature values: \n{df_sampled.iloc[selected_example].to_frame().T}')
   local_explanations_out.iloc[selected_example].plot(
       kind='barh', 
       title=f'Local explanation for the {selected_example}th example.', 
       rot=0)
   

如图 6.8所示，我们可以看到 XGBoost 模型如何预测这个数据点为<=50K。marital-status、education-num和capital-gain因素是模型认为这个人是低收入者的前三个因素。多亏了 SageMaker Clarify 计算出的 SHAP 值，我们还可以理解和解释模型是如何针对个体进行预测的。

图 6.8 – 解释单个预测

在您完成示例之后，让我们总结本章内容

摘要

在本章中，我们通过成人收入示例探讨了机器学习中的偏差和机器学习可解释性。我们了解到数据可能包含对数据集中某个特定群体或类别的不公平偏差，这可能导致机器学习模型做出不公平的预测。我们在 SageMaker Studio 中通过一个成人收入水平预测示例进行分析和计算，在模型训练之前使用SageMaker Clarify来识别任何偏差。Clarify 生成指标来量化数据集中的不平衡，这可能导致不公平的偏差。我们通过采样和匹配技术来减轻不平衡，然后继续训练机器学习模型。我们进一步使用 SageMaker Clarify 分析了结果机器学习模型在预测中的潜在偏差。最后，我们回顾了如何使用 SageMaker Clarify 和 SHAP 值来了解机器学习模型是如何做出决策的。

在下一章中，我们将学习在 SageMaker 中训练机器学习模型之后的下一步。在云中托管机器学习模型对于大多数机器学习用例至关重要，能够从 SageMaker 中选择合适的工具进行模型托管对于您组织成功采用机器学习至关重要。我们将了解托管机器学习模型的多种选项以及如何使用 SageMaker 的托管功能来优化计算资源和成本。

第七章：云中托管机器学习模型：最佳实践

在您成功训练了一个模型之后，您希望使模型可用于推理，不是吗？机器学习模型通常是 ML 驱动型企业的产品。您的客户消费的是您模型中的 ML 预测，而不是您的训练作业或处理后的数据。您如何提供令人满意的客户体验，从您 ML 模型的良好体验开始？

根据您的用例，SageMaker 提供了多种机器学习托管和推理选项。在生活的许多方面，选项都是受欢迎的，但找到最佳选项可能很困难。本章将帮助您了解如何托管用于批量推理和在线实时推理的模型，如何使用多模型端点来节省成本，以及如何针对您的推理需求进行资源优化。

在本章中，我们将涵盖以下主题：

• 训练后云中部署模型

• 批量转换中的推理

• 托管实时端点

• 优化您的模型部署

技术要求

对于本章，您需要访问github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter07中的代码。如果您在上一章中没有运行笔记本，请在继续之前，从存储库中运行chapter05/02-tensorflow_sentiment_analysis.ipynb文件。

训练后云中部署模型

机器学习模型主要可以通过两种方式在云中消费，批量推理和实时推理。批量推理指的是对批量数据进行模型推理，通常是大型批量，并且具有异步性质。它适合那些收集数据不频繁、关注群体统计而不是个体推理、并且不需要立即获得推理结果用于下游流程的场景。例如，研究导向的项目不需要立即返回数据点的模型推理。研究人员通常为了测试和评估目的收集数据块，他们更关注整体统计和性能，而不是个体预测。他们可以在批量中进行推理，并在整个批次的预测完成之前继续进行。

另一方面，实时推理指的是在实时进行的模型推理。预期对于传入的数据点的推理结果将立即返回，以便用于后续的决策过程。例如，一个交互式聊天机器人需要实时推理能力来支持此类服务。没有人愿意等到对话结束时才从聊天机器人模型那里得到回应，人们也不愿意等待超过几秒钟。希望提供最佳客户体验的公司希望推理和结果能够立即返回给客户。

由于有不同的要求，批量推理和实时推理之间的架构和部署选择也有所不同。Amazon SageMaker 提供了各种完全管理的选项来满足您的推理用例。SageMaker 批量转换旨在进行大规模的批量推理，并且由于计算基础设施是完全管理的，因此在推理作业完成后会自动取消分配，因此具有成本效益。SageMaker 实时端点旨在为您的机器学习用例提供强大的实时托管选项。SageMaker 的这两种托管选项都是完全管理的，这意味着您不必过多担心云基础设施。

让我们先看看 SageMaker 批量转换，它是如何工作的，以及在什么情况下使用它。

批量转换的推理

SageMaker 批量转换旨在为大型数据集提供离线推理。根据您如何组织数据，SageMaker 批量转换可以将单个大文本文件在 S3 中按行分割成小而可管理的尺寸（迷你批次），以便在针对模型进行推理之前放入内存中；它还可以通过 S3 键将文件分配到计算实例中进行高效计算。例如，它可以将 test1.csv 发送到实例 1，将 test2.csv 发送到实例 2。

为了演示 SageMaker 批量转换，我们可以从上一章的训练示例开始。在 第六章，“使用 SageMaker Clarify 检测机器学习偏差和解释模型”，我们向您展示了如何使用 SageMaker 管理训练在 Getting-Started-with-Amazon-SageMaker-Studio/chapter05/02-tensorflow_sentiment_analysis.ipynb. 中对电影评论情感预测用例进行 TensorFlow 模型的训练。我们可以按照以下步骤将训练好的模型部署到 SageMaker 批量转换中进行批量推理：

1. 请打开 Getting-Started-with-Amazon-SageMaker-Studio/chapter07/01-tensorflow_sentiment_analysis_batch_transform.ipynb 笔记本，并使用 Python 3 （TensorFlow 2.3 Python 3.7 CPU 优化） 内核。

2. 运行前三个单元格以设置 SageMaker SDK，导入库，并准备测试数据集。测试数据集中有 25,000 个文档。我们将测试数据保存为 CSV 文件，并将 CSV 文件上传到我们的 S3 桶中。文件大小为 27 MB。

   注意

   SageMaker 批量转换期望输入 CSV 文件不包含标题。也就是说，CSV 的第一行应该是第一个数据点。

3. 我们从第六章中提到的训练作业中检索了训练 TensorFlow 估计器，该作业是关于检测机器学习偏差和用 SageMaker Clarify 解释模型。我们需要获取用于 TensorFlow.attach() 方法的训练作业名称。您可以在左侧侧边栏的实验和试验中找到它，如图图 7.1所示，这是由于我们在训练时使用的实验。在实验和试验中，左键单击imdb-sentiment-analysis，您应该会在列表中看到您的训练作业作为一个试验。

![Figure 7.1 – 在实验和试验中获取训练作业名称

![img/B17447_07_01.jpg]

Figure 7.1 – 在实验和试验中获取训练作业名称

您应该在以下代码中将 training_job_name 替换为您自己的：

from sagemaker.tensorflow import TensorFlow
training_job_name='<your-training-job-name>'
estimator = TensorFlow.attach(training_job_name)

一旦您替换了 training_job_name 并将其附加到重新加载 estimator，您应该会在输出中看到作业的历史记录。

1. 要运行 SageMaker 批量转换，您只需要两行 SageMaker API 代码：

   transformer = estimator.transformer(instance_count=1, 
                                       instance_type='ml.c5.xlarge',
                                       max_payload = 2, # MB
                                       accept = 'application/jsonlines',
                                       output_path = s3_output_location,
                                       assemble_with = 'Line')
   transformer.transform(test_data_s3, 
                         content_type='text/csv', 
                         split_type = 'Line', 
                         job_name = jobname,
                         experiment_config = experiment_config)
   

estimator.transformer() 方法创建一个具有所需推理计算资源的 Transformer 对象。在这里，我们请求一个 ml.c5.xlarge 实例来预测 25,000 部电影评论。max_payload 参数允许我们控制 SageMaker 批量转换分割的每个 mini-batch 的大小。accept 参数确定输出类型。SageMaker 管理的 Tensorflow serving 容器支持 'application/json' 和 'application/jsonlines'。assemble_with 控制如何组装 mini-batch 中的推理结果。然后我们在 transformer.transform() 中提供测试数据的 S3 位置（test_data_s3），并指示输入内容类型为 'text/csv'，因为文件是 CSV 格式。split_type 确定 SageMaker 批量转换如何将输入文件分割成 mini-batch。我们输入一个唯一的作业名称和 SageMaker Experiments 配置，以便我们可以跟踪推理到同一试验中相关的训练作业。批量转换作业大约需要 5 分钟才能完成。像训练作业一样，一旦作业完成，SageMaker 会管理实例的配置、计算和取消配置。

1. 作业完成后，我们应该查看结果。SageMaker 批量转换在组装后将结果保存到指定的 S3 位置，并在输入文件名后附加 .out。您可以在 transformer.output_path 属性中访问完整的 S3 路径。SageMaker 使用 TensorFlow Serving，这是一个由 TensorFlow 开发的模型服务框架，用于模型服务，模型输出以 JSON 格式编写。输出包含一个数组，其中包含预测作为 JSON 键的情感概率。我们可以使用以下代码检查批量转换结果：

   output = transformer.output_path
   output_prefix = 'imdb_data/test_output'
   !mkdir -p {output_prefix}
   !aws s3 cp --recursive {output} {output_prefix}
   !head {output_prefix}/{csv_test_filename}.out
   {    "predictions": [[0.00371244829], [1.0], [1.0], [0.400452465], [1.0], [1.0], [0.163813606], [0.10115058], [0.793149233], [1.0], [1.0], [6.37737814e-14], [2.10463966e-08], [0.400452465], [1.0], [0.0], [1.0], [0.400452465], [2.65155926e-29], [4.04420768e-11], ……]}
   

然后，我们将所有 25,000 个预测收集到一个results变量中：

results=[]
with open(f'{output_prefix}/{csv_test_filename}.out', 'r') as f:
    lines = f.readlines()
    for line in lines:
        print(line)
        json_output = json.loads(line)
        result = [float('%.3f'%(item)) for sublist in json_output['predictions'] 
                                       for item in sublist]
        results += result
print(results)

1. 笔记本本的其余部分显示了一篇原始电影评论、预测的情感和相应的真实情感。模型返回评论为正面或负面的概率。我们采用0.5阈值，将超过阈值的概率标记为正面，低于0.5的标记为负面。

2. 由于我们在与训练作业相同的试验中记录了批转换作业，我们可以在左侧侧边栏的实验和试验中轻松找到它，如图 7.2 所示。您可以在本条目中查看有关此批转换作业的更多信息。

图 7.2 – 批转换作业作为试验组件与训练组件一起记录

这就是使用 SageMaker 批转换在大型数据集上生成推理是多么容易。您可能会想，为什么我不能直接使用笔记本进行推理？使用 SageMaker 批转换的好处是什么？是的，您可以使用笔记本进行快速分析。SageMaker 批转换的优势如下：

• 完全管理的迷你批处理有助于高效地对大数据集进行推理。

• 您可以使用一个独立的 SageMaker 管理的计算基础设施，这与您的笔记本实例不同。您可以使用实例集群轻松运行预测，以实现更快的预测。

• 即使使用更大的计算集群，您也只需为批转换作业的运行时间付费。

• 您可以使用 SageMaker 批转换在云中独立安排和启动模型预测。无需在 SageMaker Studio 中使用 Python 笔记本启动预测作业。

接下来，让我们看看我们如何在云中托管 ML 模型以用于实时用例。

托管实时端点

SageMaker 实时推理是一个完全管理的功能，用于在计算实例上托管您的模型（或多个模型）以实现实时低延迟推理。部署过程包括以下步骤：

1. 在 SageMaker 中创建一个模型、容器和相关的推理代码。模型指的是训练工件，model.tar.gz。容器是代码和模型的运行时环境。

2. 创建一个 HTTPS 端点配置。此配置包含有关计算实例类型和数量、模型和流量模式到模型变体的信息。

3. 创建 ML 实例和 HTTPS 端点。SageMaker 创建了一支 ML 实例和 HTTPS 端点，用于处理流量和身份验证。最后一步是将所有内容组合起来，以创建一个可以与客户端请求交互的工作 HTTPS 端点。

运行实时端点面临的一个特定挑战是，当你的端点流量激增时，这通常在托管网站或 Web 应用程序时很常见：你可能在一小时内每分钟有 1,000 名客户访问你的网站，而在下一小时有 10 万名客户。如果你只在端点后面部署一个能够每分钟处理 5,000 个请求的实例，那么在第一个小时内它会运行良好，但在下一个小时内会陷入困境。自动扩展是云中的一种技术，可以帮助你在满足某些条件时自动扩展实例，以便你的应用程序在任何时候都能处理负载。

让我们通过一个 SageMaker 实时端点示例来了解一下。就像批量转换示例一样，我们继续在第五章**，使用 SageMaker Studio IDE 构建和训练 ML 模型和 05/02-tensorflow_sentiment_analysis.ipynb 中继续 ML 用例。请打开Getting-Started-with-Amazon-SageMaker-Studio/chapter07/02-tensorflow_sentiment_analysis_inference.ipynb中的笔记本，并使用Python 3（TensorFlow 2.3 Python 3.7 CPU Optimized）内核。我们将部署一个训练好的模型到 SageMaker 作为一个实时端点，进行一些预测作为示例，并最终应用自动扩展策略来帮助扩展端点后面的计算实例。请按照以下步骤操作：

1. 在前四个单元格中，我们设置了 SageMaker 会话，加载 Python 库，加载我们在01-tensorflow_sentiment_analysis_batch_transform.ipynb中创建的测试数据，并使用其名称检索我们之前训练的训练作业。

2. 然后，我们将模型部署到端点：

   predictor = estimator.deploy(
                    instance_type='ml.c5.xlarge',
                    initial_instance_count=1)
   

在这里，我们选择ml.c5.xlarge作为instance_type参数。initial_instance_count参数指的是我们调用此参数时端点后面的 ML 实例数量。稍后，我们将向您展示如何使用自动扩展功能，该功能旨在帮助我们扩展实例群，当初始设置不足时。部署过程大约需要 5 分钟。

1. 我们可以用一些样本数据测试端点。容器中的 TensorFlow Serving 框架处理数据接口，并接受 NumPy 数组作为输入，因此我们可以直接将条目传递给模型。我们可以从端点获得 JSON 格式的响应，该响应在 Python 中的prediction变量中被转换为字典：

   prediction=predictor.predict(x_test[data_index])
   print(prediction)
   {'predictions': [[1.80986511e-11]]}
   

接下来的两个单元格检索文本评论，并打印出带有 0.5 阈值的真实情感和预测情感，就像在批量转换示例中一样。

1. (可选) 你可能想知道：我能否让端点预测 25,000 个数据点的整个x_test？为了找到答案，请随意尝试以下行：

   predictor.predict(x_test)
   

这行代码将运行几秒钟，最终失败。这是因为 SageMaker 端点设计为一次处理 6 MB 大小的请求。例如，您可以请求多个数据点的推理，例如 x_test[:100]，但不能在一次调用中请求 25,000 个。相比之下，批量转换会自动进行数据拆分（迷你批处理），更适合处理大型数据集。

1. 接下来，我们可以使用 boto3 SDK 中的 application-autoscaling 客户端将 SageMaker 的自动缩放功能应用于此端点：

   sagemaker_client = sess.boto_session.client('sagemaker')
   autoscaling_client = sess.boto_session.client('application-autoscaling')
   

2. 在 AWS 中为计算实例配置自动缩放是一个两步过程。首先，我们运行 autoscaling_client.register_scalable_target() 以将目标与我们的 SageMaker 端点所需的期望最小/最大容量注册：

   resource_id=f'endpoint/{endpoint_name}/variant/AllTraffic' 
   response = autoscaling_client.register_scalable_target(
      ServiceNamespace='sagemaker',
      ResourceId=resource_id,
   ScalableDimension='sagemaker:variant:DesiredInstanceCount',
      MinCapacity=1,
      MaxCapacity=4)
   

我们的目标，SageMaker 实时端点，用 resource_id 表示。我们将最小容量设置为 1，最大容量设置为 4，这意味着当负载最低时，至少有一个实例在端点后面运行。我们的端点最多可以扩展到四个实例。

1. 然后我们运行 autoscaling_client.put_scaling_policy() 来指示我们想要如何自动缩放：

   response = autoscaling_client.put_scaling_policy(
      PolicyName='Invocations-ScalingPolicy',
      ServiceNamespace='sagemaker',
      ResourceId=resource_id, 
      ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
      PolicyType='TargetTrackingScaling', 
      TargetTrackingScalingPolicyConfiguration={
          'TargetValue': 4000.0, 
          'PredefinedMetricSpecification': {
             'PredefinedMetricType': 
                'SageMakerVariantInvocationsPerInstance'},
           'ScaleInCooldown': 600, 
           'ScaleOutCooldown': 300})
   

在此示例中，我们采用了一种名为 SageMakerVariantInvocationsPerInstance 的缩放策略，在此配置中确保每个实例在扩展另一个实例之前可以每分钟共享 4,000 个请求。ScaleInCooldown 和 ScaleOutCooldown 指的是在自动缩放可以再次进行缩放之前，最后一次缩放活动后的秒数。根据我们的配置，SageMaker 不会在最后一次缩放活动后的 600 秒内进行缩放（移除实例），也不会在最后一次缩放活动后的 300 秒内进行扩展（添加实例）。

注意

对于 PolicyType，有两种常用的高级缩放策略：步进缩放和计划缩放。在步进缩放中，您可以根据某个指标的警报越界大小定义要缩放/缩出的实例数量。有关步进缩放的更多信息，请参阅 docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html。在计划缩放中，您可以根据计划设置缩放。如果流量可预测或具有某种季节性，这特别有用。有关计划缩放的更多信息，请参阅 docs.aws.amazon.com/autoscaling/ec2/userguide/schedule_time.html。

1. 我们可以使用以下代码验证自动缩放策略的配置：

   response = autoscaling_client.describe_scaling_policies(
            ServiceNamespace='sagemaker')
   for i in response['ScalingPolicies']:
       print('')
       print(i['PolicyName'])
       print('')
       if('TargetTrackingScalingPolicyConfiguration' in i):
           print(i['TargetTrackingS calingPolicyConfiguration']) 
       else:
           print(i['StepScalingPolicyConfiguration'])
       print('')
   Invocations-ScalingPolicy
   {'TargetValue': 4000.0, 'PredefinedMetricSpecification': {'PredefinedMetricType': 'SageMakerVariantInvocationsPerInstance'}, 'ScaleOutCooldown': 300, 'ScaleInCooldown': 600}
   

2. 在 Amazon SageMaker Studio 中，您可以在左侧侧边栏的 Endpoints 注册表中轻松找到端点的详细信息，如图 图 7.3 所示。如果您双击一个端点，您可以在主工作区域看到更多信息：

图 7.3 – 在 SageMaker Studio 中查找端点

运行端点的目的是在云中提供机器学习模型，以便您可以将机器学习作为微服务集成到您的应用程序或网站上。只要您的核心产品或服务可用，您的模型就必须始终可用。您可以想象，优化部署以最小化成本同时保持性能，这对您来说是一个巨大的机会和激励。我们刚刚学习了如何在云中部署机器学习模型；我们也应该学习如何优化部署。

优化您的模型部署

优化模型部署是企业的一个关键话题。没有人愿意多花一分钱。因为部署的端点正在持续使用，并且持续产生费用，确保部署在成本和运行时性能方面得到优化可以为您节省大量资金。SageMaker 有几个选项可以帮助您在优化运行时性能的同时降低成本。在本节中，我们将讨论多模型端点部署以及如何为您的用例选择实例类型和自动扩展策略。

运行多模型端点以节省成本

多模型端点是 SageMaker 中的一种实时端点，允许在同一个端点后面部署多个模型。有许多用例，您会为每个客户或每个地理区域构建模型，并且根据传入数据点的特征，您将应用相应的机器学习模型。以我们在第三章中解决的电信流失预测用例为例，使用 SageMaker Data Wrangler 进行数据准备。如果我们按州训练它们，可能会得到更准确的机器学习模型，因为当地电信提供商之间的竞争可能存在地区差异。如果我们为每个美国州训练机器学习模型，您也可以很容易地想象到每个模型的利用率可能并不完全相等。实际上，恰恰相反。

模型利用率不可避免地与每个州的居民人数成比例。您的纽约模型将比您的阿拉斯加模型使用得更频繁。在这种情况下，如果您为每个州运行一个端点，您将不得不为最少使用的端点付费。使用多模型端点，SageMaker 可以帮助您通过减少您用例所需的端点数量来降低成本。让我们看看它是如何与电信流失预测用例一起工作的。请使用 Python 3（数据科学）内核打开Getting-Started-with-Amazon-SageMaker-Studio/chapter07/03-multimodel-endpoint.ipynb笔记本，并按照以下步骤操作：

1. 我们定义了 SageMaker 会话，在前三个单元中加载 Python 库，并加载流失数据集。

2. 我们进行最小化预处理，将二进制列从字符串转换为0和1：

   df[["Int'l Plan", "VMail Plan"]] = df[["Int'l Plan", "VMail Plan"]].replace(to_replace=['yes', 'no'], value=[1, 0])
   df['Churn?'] = df['Churn?'].replace(to_replace=['True.', 'False.'], value=[1, 0])
   

3. 我们为后续的 ML 推理留出了 10% 的数据：

   from sklearn.model_selection import train_test_split
   df_train, df_test = train_test_split(df_processed,
            test_size=0.1, random_state=42, shuffle=True, 
            stratify=df_processed['State'])
   

4. 数据准备完成后，我们使用 SageMaker Experiments 集成在函数 launch_training_job() 中设置我们的状态模型训练过程。我们使用的训练算法是 SageMaker 内置的 XGBoost 算法，对于这种结构化数据来说，它既快又准确。对于二元分类，我们使用 binary:logtistic 目标，并将 num_round 设置为 20：

   def launch_training_job(state, train_data_s3, val_data_s3):
       ...
       xgb = sagemaker.estimator.Estimator(image, role,
             instance_count=train_instance_count,
             instance_type=train_instance_type,
             output_path=s3_output,
             enable_sagemaker_metrics=True,
             sagemaker_session=sess)
       xgb.set_hyperparameters(
             objective='binary:logistic',
             num_round=20)
   
       ...    
       xgb.fit(inputs=data_channels, 
               job_name=jobname, 
               experiment_config=experiment_config, 
               wait=False)
       return xgb
   

5. 使用 launch_training_job()，我们可以通过 for 循环轻松地为状态创建多个训练作业。为了演示目的，我们在这个例子中只训练了五个状态：

   dict_estimator = {}
   for state in df_processed.State.unique()[:5]:
       print(state)
       output_dir = f's3://{bucket}/{prefix}/{local_prefix}/by_state'
       df_state = df_train[df_train['State']==state].drop(labels='State', axis=1)
       df_state_train, df_state_val = train_test_split(df_state, test_size=0.1, random_state=42, 
                                                       shuffle=True, stratify=df_state['Churn?'])
   
       df_state_train.to_csv(f'{local_prefix}/churn_{state}_train.csv', index=False)
       df_state_val.to_csv(f'{local_prefix}/churn_{state}_val.csv', index=False)
       sagemaker.s3.S3Uploader.upload(f'{local_prefix}/churn_{state}_train.csv', output_dir)
       sagemaker.s3.S3Uploader.upload(f'{local_prefix}/churn_{state}_val.csv', output_dir)
   
       dict_estimator[state] = launch_training_job(state, out_train_csv_s3, out_val_csv_s3)
       time.sleep(2)
   

每个训练作业不应超过 5 分钟。我们将在使用 wait_for_training_job_to_complete() 函数之前等待所有作业完成。

1. 训练完成后，我们最终部署我们的多模型端点。与从训练估计器对象部署单个模型到端点相比，这有点不同。我们使用 sagemaker.multidatamodel.MultiDataModel 类进行部署：

   model_PA = dict_estimator['PA'].create_model(
          role=role, image_uri=image)
   mme = MultiDataModel(name=model_name,               
          model_data_prefix=model_data_prefix,
          model=model_PA,
          sagemaker_session=sess)
   

MultiDataModel 初始化需要了解常见的模型配置，例如容器镜像和网络配置，以配置端点配置。我们传递模型给 PA。之后，我们将模型部署到一个 ml.c5.xlarge 实例上，并配置 serializer 和 deserializer 分别以 CSV 作为输入，以 JSON 作为输出：

predictor = mme.deploy(
       initial_instance_count=hosting_instance_count, 
       instance_type=hosting_instance_type, 
       endpoint_name=endpoint_name,
       serializer = CSVSerializer(),
       deserializer = JSONDeserializer())

1. 然后，我们可以动态地向端点添加模型。请注意，在此时刻，端点后面还没有部署任何模型：

   for state, est in dict_estimator.items():
       artifact_path = est.latest_training_job.describe()['ModelArtifacts']['S3ModelArtifacts']
       model_name = f'{state}.tar.gz'
       mme.add_model(model_data_source=artifact_path, 
                     model_data_path=model_name)
   

就这样。我们可以验证与该端点关联有五个模型：

list(mme.list_models())
['MO.tar.gz', 'PA.tar.gz', 'SC.tar.gz', 'VA.tar.gz', 'WY.tar.gz']

1. 我们可以使用每个状态的一些数据点来测试端点。您可以使用 predictor.predict() 中的 target_model 参数指定要用于推理的模型：

   state='PA'
   test_data=sample_test_data(state)
   prediction = predictor.predict(data=test_data[0], 
                                  target_model=f'{state}.tar.gz')
   

在这个单元格以及之后，我们还设置了一个计时器来测量其他状态模型响应所需的时间，以便说明模型从 S3 到端点的动态加载特性。当端点首次创建时，端点后面没有模型。使用 add_model()，它仅仅将模型上传到 S3 位置，model_data_prefix。当首次请求模型时，SageMaker 会动态地从 S3 下载请求的模型到 ML 实例，并将其加载到推理容器中。当我们首次为每个状态模型进行预测时，这个过程有较长的响应时间，高达 1,000 毫秒。但一旦模型被加载到端点后面的容器内存中，响应时间会大大减少，大约为 20 毫秒。当模型被加载时，它会被保存在容器中，直到实例的内存因一次性加载太多模型而被耗尽。然后 SageMaker 会从内存中卸载不再使用的模型，同时在实例的磁盘上保留 model.tar.gz，以便下次请求避免从 S3 下载。

在本例中，我们展示了如何托管一个灵活且经济的 SageMaker 多模型端点，因为它大大减少了您用例所需的端点数量。因此，我们不会托管和支付五个端点的费用，而只需托管和支付一个端点的费用。这将节省 80% 的成本。在 1 个端点中托管为 50 个美国州训练的模型，而不是 50 个，这将节省 98% 的成本！

使用 SageMaker 多模型端点，您可以在 S3 存储桶位置托管尽可能多的模型。您可以在端点中加载的模型数量取决于您模型的内存占用和计算实例上的 RAM 量。多模型端点适用于您有在相同框架（本例中为 XGBoost）中构建的模型，并且可以容忍较少使用模型的延迟的情况。

注意

如果您有由不同的机器学习框架构建的模型，例如 TensorFlow、PyTorch 和 XGBoost 模型的混合，您可以使用多容器端点，这允许托管多达 15 个不同的框架容器。多容器端点的另一个好处是，由于所有容器同时运行，它们没有延迟惩罚。更多信息请参阅docs.aws.amazon.com/sagemaker/latest/dg/multi-container-endpoints.html。

另一种优化方法是使用称为压力测试的技术来帮助我们选择实例和自动扩展策略。

使用压力测试优化实例类型和自动扩展

压力测试是一种技术，它使我们能够了解我们的机器学习模型在具有计算资源配置的端点上如何响应在线流量。模型大小、机器学习框架、CPU 数量、RAM 量、自动扩展策略和流量大小等因素会影响您的机器学习模型在云中的表现。显然，预测一段时间内可以到达端点的请求数量并不容易。理解模型和端点在这种复杂情况下的行为是明智的。压力测试为您的端点创建人工流量和请求，并测试模型和端点在模型延迟、实例 CPU 利用率、内存占用等方面的响应。

在本节中，我们将对在 chapter07/02-tensorflow_sentiment_analysis_inference.ipynb 中创建的端点进行一些场景的压力测试。在示例中，我们将一个基于 TensorFlow 的模型托管到具有 4 个 vCPU 和 8 GiB 内存 ml.c5.xlarge 实例上。

首先，我们需要在端点不可用之前理解模型的延迟和容量作为实例类型和实例数量的函数。然后我们调整实例配置和自动扩展配置，直到达到所需的延迟和流量容量。

请使用 ml.t3.xlarge 实例打开 Getting-Started-with-Amazon-SageMaker-Studio/chapter07/04-load_testing.ipynb 笔记本，并按照以下步骤操作：

1. 我们在 SageMaker Studio 中使用一个名为 locust 的 Python 压力测试框架来进行负载测试。首先在笔记本中下载这个库。你可以在 docs.locust.io/en/stable/index.html 上了解更多关于这个库的信息。

2. 如同往常，我们在第二个单元中设置 SageMaker 会话。

3. 创建一个负载测试配置脚本，load_testing/locustfile.py，这是 locust 所必需的。该脚本也包含在存储库中。这个单元会覆盖文件。在这个配置中，我们指示 locust 创建模拟用户（SMLoadTestUser 类）来对 SageMaker 端点（由环境变量提供的 test_endpoint 类函数）进行模型推理，数据点从 imdb_data/test/test.csv 加载。在这里，响应时间 total_time 以 毫秒（ms）为单位进行测量。

4. 在下一个单元中，我们使用 ml.c5.xlarge 实例在我们已经部署的 SageMaker 端点上进行第一次负载测试工作。记得我们在 chapter07/02-tensorflow_sentiment_analysis_inference 中应用了自动扩展策略吗？让我们首先通过将 MaxCapacity 设置为 1 来反转策略，以确保在第一次测试期间端点不会扩展到多个实例：

   sagemaker_client = sess.boto_session.client('sagemaker')
   autoscaling_client = sess.boto_session.client('application-autoscaling')
   endpoint_name = '<endpoint-with-ml.c5-xlarge-instance>'
   resource_id = f'endpoint/{endpoint_name}/variant/AllTraffic' 
   response = autoscaling_client.register_scalable_target(
      ServiceNamespace='sagemaker',
      ResourceId=resource_id,
      ScalableDimension='sagemaker:variant:   DesiredInstanceCount',
      MinCapacity=1,
      MaxCapacity=1)
   

5. 然后我们使用 locust 测试端点。在下面的代码片段中，我们设置了在两个 CPU 核心上进行的两个工作者的分布式负载测试。我们指示 locust 每秒创建 10 个用户（-r 10 参数），最多 500 个在线用户（-u 500），每个用户对端点进行 60 秒（-t 60s）的调用。请将 ENDPOINT_NAME 字符串替换为你的 SageMaker 端点名称。你可以在 Endpoints 注册表中找到端点名称，如图 7.3 所示：

   %%sh --bg
   export ENDPOINT_NAME='<endpoint-with-ml.c5-xlarge-instance>'
   bind_port=5557
   locust -f load_testing/locustfile.py --worker --loglevel ERROR --autostart --autoquit 10 --master-port ${bind_port} & 
   locust -f load_testing/locustfile.py --worker --loglevel ERROR --autostart --autoquit 10 --master-port ${bind_port} &
   locust -f load_testing/locustfile.py --headless -u 500 -r 10 -t 60s \
          --print-stats --only-summary --loglevel ERROR \
          --autostart --autoquit 10 --master --expect-workers 2 --master-bind-port ${bind_port}
   

当它正在运行时，让我们导航到 <endpoint-with-ml.c5-xlarge-instance> 并用你的端点名称替换它，如果你使用的是除 us-west-2 之外的区域：
https://us-west-2.console.aws.amazon.com/cloudwatch/home?region=us-west-2#metricsV2:graph=~(metrics~(~(~'AWS*2fSageMaker~'InvocationsPerInstance~'EndpointName~'<endpoint-with-ml.c5-xlarge-instance>~'VariantName~'AllTraffic)~(~'.~'ModelLatency~'.~'.~'.~'.~(stat~'Average'))~(~'.~'Invocations~'.~'.~'.~'.)~(~``'.~'OverheadLatency~'.~'.~'.~'.~(stat~'Average'))~(~'.~'Invoca tion5XXErrors~'.~'.~'.~'.)~(~'.~'Invocation4XXErrors~'.~'.~'.~'.))~view~'timeSeries~stacked~false~region~'us-west-2~stat~'Sum~period~60~start~'-PT3H~end~'P0D );query=~'*7bAWS*2fSageMaker*2cEndpointName*2cVariantName*7d*20<endpoint-with-ml.c5-xlarge-instance>

你可以在图 7.4中看到一个仪表板。仪表板捕获了我们 SageMaker 端点健康和状态的最重要指标。Invocations和InvocationsPerInstance显示了总的调用次数和每个实例的计数。Invocation5XXErrors和Invocation4XXErrors分别表示带有 HTTP 代码 5XX 和 4XX 的错误计数。ModelLatency（以微秒为单位）是 SageMaker 端点后面容器中的模型返回响应所需的时间。OverheadLatency（以微秒为单位）是我们 SageMaker 端点传输请求和响应所需的时间。请求的总延迟是ModelLatency加上OverheadLatency。这些指标是由我们的 SageMaker 端点发送到 Amazon CloudWatch 的。

![Figure 7.4 – 在 Amazon CloudWatch 中查看单个 ml.c5.xlarge 实例的负载测试结果

![img/B17447_07_04.jpg]

图 7.4 – 在 Amazon CloudWatch 中查看单个 ml.c5.xlarge 实例的负载测试结果

在第一次负载测试（图 7.4）中，我们可以看到每分钟大约有 8,221 次调用，0 个错误，平均ModelLatency为53,825微秒，即 53.8 毫秒。

在这些数字作为基准的情况下，让我们扩展实例，也就是说，让我们使用更大的实例。

1. 我们加载了之前的 IMDb 情感分析训练作业，并将 TensorFlow 模型部署到另一个端点，该端点有一个ml.c5.2xlarge实例，该实例有 8 个 vCPU 和 16 GiB 的内存，是ml.c5.xlarge的两倍：

   from sagemaker.tensorflow import TensorFlow
   training_job_name='<your-training-job-name>'
   estimator = TensorFlow.attach(training_job_name)
   predictor_c5_2xl = estimator.deploy(
             initial_instance_count=1, 
             instance_type='ml.c5.2xlarge')
   

部署过程需要几分钟。然后我们使用下一个单元格predictor_c5_2xl.endpoint_name检索端点名称。

1. 将ENDPOINT_NAME替换为predictor_c5_2xl.endpoint_name的输出，并运行单元格以启动针对新端点的另一个负载测试：

   export ENDPOINT_NAME='<endpoint-with-ml.c5-2xlarge-instance>'
   

2. 在 Amazon CloudWatch（在步骤 4中的长 URL 中替换<endpoint-with-ml.c5-xlarge-instance>或点击笔记本中下一个单元格生成的超链接），我们可以在图 7.5中看到端点对流量的响应：

![Figure 7.5 – 在 Amazon CloudWatch 中查看单个 ml.c5.2xlarge 实例的负载测试结果

![img/B17447_07_05.jpg]

图 7.5 – 在 Amazon CloudWatch 中查看单个 ml.c5.2xlarge 实例的负载测试结果

同样，locust 能够生成的流量大约是每分钟 8,000 次调用（ml.c5.xlarge实例）。

1. 接下来，我们将相同的模型部署到ml.g4dn.xlarge实例上，这是一个专门用于模型推理用例的 GPU 实例。G4dn 实例配备了 NVIDIA T4 GPU，对于 ML 推理和小型神经网络训练作业来说性价比很高：

   predictor_g4dn_xl = estimator.deploy(
            initial_instance_count=1,        
            instance_type='ml.g4dn.xlarge')
   

2. 我们设置了一个类似于之前的负载测试任务。结果也可以在 Amazon CloudWatch 仪表板上找到，只需在步骤 4中将长 URL 中的<endpoint-with-ml.c5-xlarge-instance>替换，或者点击笔记本中下一个单元格生成的超链接。如图图 7.6所示，每分钟大约有 6,000 次调用，平均的ml.g4dn.xlarge实例进行推理的速度更快。

![Figure 7.6 – 在 Amazon CloudWatch 中查看单个 ml.g4dn.xlarge 实例的负载测试结果

![img/B17447_07_06.jpg]

Figure 7.6 – 在 Amazon CloudWatch 中查看单个 ml.g4dn.xlarge 实例的负载测试结果

1. 我们应该尝试的最后一种方法是自动扩展。自动扩展允许我们将负载分散到实例上，这反过来有助于提高 CPU 利用率和模型延迟。我们再次将自动扩展设置为MaxCapacity=4，如下单元格所示：

   endpoint_name = '<endpoint-with-ml.c5-xlarge-instance>'
   resource_id=f'endpoint/{endpoint_name}/variant/AllTraffic'
   response = autoscaling_client.register_scalable_target(
      ServiceNamespace='sagemaker',
      ResourceId=resource_id,
      ScalableDimension='sagemaker:variant:DesiredInstanceCount',
      MinCapacity=1,
      MaxCapacity=4)
   

您可以通过笔记本中下一个单元格附加的扩展策略来确认。

1. 我们准备进行最后的负载测试实验。将ENDPOINT_NAME替换为<endpoint-with-ml.c5-xlarge-instance>，并运行下一个单元格以启动针对现在能够扩展到四个实例的端点的负载测试。这个负载测试需要运行更长的时间，以便看到自动扩展的效果。这是因为 SageMaker 首先需要观察调用次数，然后根据我们的目标指标SageMakerVariantInvocationsPerInstance=4000来决定需要多少新实例。在我们的流量大约每分钟 8,000 次调用的情况下，SageMaker 将启动一个额外的实例，以实现每个实例的调用次数达到期望值，即 4,000。启动新实例需要大约 5 分钟才能完成。

![Figure 7.7 – 在 Amazon CloudWatch 中查看具有自动扩展的 ml.c5.xlarge 实例的负载测试结果

![img/B17447_07_07.jpg]

Figure 7.7 – 在 Amazon CloudWatch 中查看具有自动扩展的 ml.c5.xlarge 实例的负载测试结果

我们可以在 Amazon CloudWatch 仪表板上看到负载测试结果，如图图 7.7所示。我们可以在图表中看到有趣的模式。我们可以清楚地看到在18:48和18:49之间发生了某些事情。33,839微秒（33.8 毫秒）。并且SageMakerVariantInvocationsPerInstance=4000将流量分成两个实例。较低的模型延迟是多个实例分担负载的理想结果。

经过四次负载测试实验后，我们可以得出结论，在每分钟大约 6,000 到 8,000 次调用的负载下，以下情况发生：

• 单实例性能是通过平均ml.g4dn.xlarge（1 个 GPU 和 4 个 vCPU）来衡量的，它给出了最小的ml.c5.2xlarge实例（8 个 vCPU）在 45.8 毫秒。最后是ml.c5.xlarge实例（4 个 vCPU）在 53.8 毫秒。

• 使用自动扩展，两个具有 8 个 vCPU 的ml.c5.xlarge实例实现了与相同数量的 vCPU 的ml.c5.2xlarge在 33.8 毫秒的ml.c5.2xlarge。

如果我们考虑另一个维度，即实例的成本，我们可以遇到一个更有趣的情况，如图图 7.8所示。在表中，我们创建了一个简单的复合指标，通过将模型延迟乘以实例配置的每小时价格来衡量配置的成本性能效率。

图 7.8 – 成本性能比较

如果我们受限于成本，我们应该考虑使用最后一个配置（行 d），其中月度成本最低，同时牺牲一些模型延迟，但成本性能效率位居第二。如果我们需要大约 40 毫秒或更低的模型延迟，通过支付相同的月度成本，我们使用第三个配置（行 c）比第二个配置（行 b）可以获得更多的性价比和更低的延迟。第一个配置（行 a）提供最佳的模型延迟和最佳的成本性能效率。但这也是最昂贵的选项。除非有严格的个位数模型延迟要求，我们可能不想使用这个选项。

为了降低成本，当你完成示例后，确保取消注释并运行02-tensorflow_sentiment_analysis_inference.ipynb、03-multimodel-endpoint.ipynb和04-load_testing.ipynb中的最后几个单元格，以删除端点，从而停止向您的 AWS 账户收取费用。

这场讨论基于我们使用的示例，它假设了许多因素，例如模型框架、流量模式和实例类型。你应该遵循我们为你的用例介绍的最佳实践，并测试更多实例类型和自动扩展策略，以找到最适合你用例的解决方案。你可以在aws.amazon.com/sagemaker/pricing/的实时推理标签页中找到完整的实例列表、规格和每小时价格，以进行你自己的成本性能效率分析。

SageMaker 中还有其他优化功能可以帮助您降低延迟，例如 Amazon Elastic Inference、SageMaker Neo 和 Amazon EC2 Inf1 实例。弹性推理（Elastic Inference）(docs.aws.amazon.com/sagemaker/latest/dg/ei-endpoints.html) 将部分 GPU 连接到 SageMaker 托管端点。它增加了深度学习模型的推理吞吐量并降低了模型延迟，这些模型可以从 GPU 加速中受益。SageMaker Neo (docs.aws.amazon.com/sagemaker/latest/dg/neo.html) 在云和边缘支持的设备上优化机器学习模型进行推理，而不会损失精度。SageMaker Neo 通过在 SageMaker 托管端点中使用编译的模型和优化的容器来加速预测并降低成本。Amazon EC2 Inf1 实例(aws.amazon.com/ec2/instance-types/inf1/) 在云中提供高性能和低成本，使用的是 AWS 为机器学习推理目的设计和构建的 AWS Inferentia 芯片。您可以使用 SageMaker Neo 编译支持的机器学习模型，并选择 Inf1 实例在 SageMaker 托管端点中部署编译后的模型。

摘要

在本章中，我们学习了如何使用 Amazon SageMaker 在云中高效地进行机器学习推理。我们接着学习了上一章中训练的内容——IMDb 电影评论情感预测，以展示 SageMaker 的批量转换和实时托管。更重要的是，我们学习了如何通过负载测试来优化成本和模型延迟。我们还了解了通过使用 SageMaker 多模型端点在单个端点托管多个机器学习模型来节省成本的机会。一旦您为您的用例选择了最佳推理选项和实例类型，SageMaker 就会使模型部署变得简单直接。有了这些逐步说明和讨论，您将能够将所学知识应用到您自己的机器学习用例中。

在下一章中，我们将采取不同的路径来学习如何使用 SageMaker 的 JumpStart 和 Autopilot 快速启动您的机器学习之旅。SageMaker JumpStart 提供解决方案，帮助您了解如何应对最佳实践和机器学习用例。JumpStart 模型动物园收集了众多预训练的深度学习模型，用于自然语言处理和计算机视觉用例。SageMaker Autopilot 是一个自动机器学习（autoML）功能，它可以处理数据并训练性能良好的模型，而无需您担心数据、编码或建模。在我们学习了 SageMaker 的基础知识——完全托管模型训练和模型托管之后，我们可以更好地理解 SageMaker JumpStart 和 Autopilot 的工作原理。

第八章：使用 SageMaker JumpStart 和 Autopilot 快速启动机器学习

SageMaker JumpStart 作为 Amazon SageMaker 机器学习（ML）世界入门套件，为选定的用例提供完整解决方案，无需任何代码开发。SageMaker JumpStart 还为您整理了流行的预训练 计算机视觉（CV）和 自然语言处理（NLP）模型，以便您轻松部署或微调到您的数据集。SageMaker Autopilot 是一种 AutoML 解决方案，它探索您的数据，代表您构建特征，并从各种算法和超参数中训练最优模型。您无需编写任何代码：Autopilot 会为您完成，并返回笔记本以展示它是如何做到的。

在本章中，我们将涵盖以下主题：

• 启动 SageMaker JumpStart 解决方案

• 从 SageMaker JumpStart 模型库部署和微调模型

• 使用 SageMaker Autopilot 创建高质量模型

技术要求

对于本章，您需要拥有使用 JumpStart 模板的权利。您可以从您的域和用户配置文件中确认。本章使用的代码可以在 github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter08 找到。

启动 SageMaker JumpStart 解决方案

如果您想学习一套 AWS 服务如何一起使用以创建 ML 解决方案的最佳实践，SageMaker JumpStart 特别有用。您也可以这样做。让我们打开 JumpStart 浏览器。打开它的方式有多种，如图 图 8.1 所示。您可以从右侧的 SageMaker Studio 启动器或左侧的 JumpStart 资产浏览器打开它。

![图 8.1 – 从启动器或左侧侧边栏打开 JumpStart 浏览器

图 8.1 – 从启动器或左侧侧边栏打开 JumpStart 浏览器

在主工作区域将弹出一个名为 SageMaker JumpStart 的新标签页。转到 解决方案 部分，点击 查看所有，如图 图 8.2 所示。

![图 8.2 – 在 JumpStart 中查看所有解决方案

图 8.2 – 在 JumpStart 中查看所有解决方案

接下来，让我们转向行业解决方案目录。

行业解决方案目录

如 图 8.3 所示，JumpStart 中有十多种解决方案可供选择。这些解决方案基于涵盖多个行业的用例，包括制造、零售和金融。

![图 8.3 – JumpStart 解决方案目录 – 点击每张卡片查看更多信息

图 8.3 – JumpStart 解决方案目录 – 点击每张卡片查看更多信息

它是由了解该行业和用例的 AWS 开发人员和架构师创建的。您可以通过点击卡片了解更多关于每个用例的信息。您将看到一个欢迎页面，描述用例、方法、数据集、解决方案架构以及任何其他外部资源。在每个解决方案页面上，您还应该看到一个启动按钮，该按钮将从 CloudFormation 模板部署解决方案和所有云资源到您的 AWS 账户。

让我们以目录中的产品缺陷检测解决方案为例，我们将一起了解部署和笔记本。

部署产品缺陷检测解决方案

视觉检查在制造过程中被广泛采用作为一种质量控制措施。质量控制过去是一个手动过程，员工会在生产线或通过相机捕获的图像上对产品进行视觉检查。然而，对于今天工厂中生产的大量产品，手动检查无法扩展。机器学习是一个强大的工具，可以以可能比经过适当训练的人类检查员更低的错误率识别产品缺陷。产品缺陷检测 SageMaker JumpStart 解决方案是一个很好的起点，可以帮助您启动 CV 项目，使用最先进的深度学习模型检测图像中的缺陷。您将了解 SageMaker 如何使用 PyTorch 脚本进行训练管理，以及如何使用模型托管。您还将学习如何对托管端点进行推理。数据集是一个平衡的数据集，包含六种表面缺陷的类型，并包含分类和绘制边界框的地面真实值。请按照以下步骤阅读笔记本的内容：

1. 从解决方案目录中，请选择产品缺陷检测图像。如图 8.4 所示，您可以在主页上了解解决方案。您可以了解样本数据、算法和云解决方案架构。

图 8.4 – 产品缺陷检测图像解决方案的主页

1. 点击如图 8.4 所示的启动按钮开始部署。您应该在屏幕上看到部署进度。正在发生的事情是我们刚刚在后台使用AWS CloudFormation启动了一个资源部署。AWS CloudFormation 是一种服务，它通过 JSON 或 YAML 声明性代码中的模板，以有序的方式帮助创建、配置和管理 AWS 资源。此部署需要几分钟。

2. 一旦解决方案变为 0_demo.ipynb，从解决方案中运行。这个笔记本是四个笔记本中的第一个，作为 CloudFormation 设置的一部分部署到你的家目录 S3Downloads/jumpstart-prod-dfd_xxxxxxx/notebooks/ 中。该笔记本需要 SageMaker JumpStart PyTorch 1.0 内核，因为我们将要构建一个基于 PyTorch 的解决方案。如果这是第一次使用内核，内核启动可能需要一两分钟。

3. 运行 0_demo.ipynb 笔记本中的所有单元格。该笔记本将 NEU-DET 检测数据集下载到文件系统，并使用 SageMaker SDK 的 sagemaker.pytorch.PyTorchModel 类创建一个用于预训练 PyTorch 模型的 SageMaker 托管端点。在笔记本末尾，你应该看到一个显示预训练模型检测到的补丁与真实值相比的图像，如图 图 8.5 所示。

图 8.5 – 0_demo.ipynb 笔记本最终输出，展示了一个钢表面示例、真实值和预训练模型进行的模型预测

该笔记本演示了 SageMaker 提供的关键灵活性，即你可以将 SageMaker 外部训练的模型带到 SageMaker 中托管。要从 PyTorch 模型创建 SageMaker 模型，你需要将模型文件 .pt/.pth 存档在 model.tar.gz 归档中，并有一个入口点，在这个例子中是 detector.py 脚本，该脚本指示如何进行推理。我们可以查看 detector.py 脚本来了解更多信息。

1. （可选）添加一个新的单元格并填写以下命令：

   !aws s3 cp {sources}source_dir.tar.gz .
   !tar zxvf source_dir.tar.gz
   

这将获取整个代码库到本地。请打开 detector.py 文件，找到 SageMaker 用于进行推理的部分：

def model_fn(model_dir):
    backbone = "resnet34"
    num_classes = 7  # including the background
    mfn = load_checkpoint(Classification(backbone, num_classes - 1).mfn, model_dir, "mfn")
    rpn = load_checkpoint(RPN(), model_dir, "rpn")
    roi = load_checkpoint(RoI(num_classes), model_dir, "roi")
    model = Detection(mfn, rpn, roi)
    model = model.eval()
    freeze(model)
    return model

当导入 PyTorch 模型时，SageMaker 至少需要一个 model_fn(model_dir) 函数来指示模型是如何定义的。在这个例子中，Detection() 类是一个在 S3Downloads/jumpstart-prod-dfd_xxxxxx/notebooks/sagemaker_defect_detection/models/ddn.py 中定义的 GeneralizedRCNN 模型，其权重是从提供的模型中加载的。

注意

你可以实现的其它相关推理函数包括以下内容：

将调用请求体反序列化为我们可以对其执行预测的对象：

input_object = input_fn(request_body, request_content_type)

使用加载的模型对反序列化的对象进行预测：

prediction = predict_fn(input_object, model)

将预测结果序列化为所需的响应内容类型：

output = output_fn(prediction, response_content_type)

如果你没有覆盖这些函数，SageMaker 为这三个函数提供了默认实现。如果你有自定义的推理方法，你可以覆盖这些函数。

1. 继续到笔记本的末尾并点击 1_retrain_from_checkpoint.ipynb。

2. 运行 1_retrain_from_checkpoint.ipynb 笔记本中的所有单元格。这个笔记本使用下载的数据集对预训练模型进行了额外的几个周期的微调。解决方案包括 detector.py 文件中的训练代码，该文件位于 osp.join(sources, "source_dir.tar.gz")。解决方案使用 SageMaker SDK 的 PyTorch 估算器创建一个训练作业，该作业启动一个按需计算资源，即一个 ml.g4dn.2xlarge 实例，并从提供的预训练检查点开始训练。训练大约需要 10 分钟。以下代码行显示了如何将训练数据和预训练检查点输入到 SageMaker PyTorch 估算器以执行模型微调作业：

   finetuned_model.fit(
       {
           "training": neu_det_prepared_s3,
           "pretrained_checkpoint": osp.join(s3_pretrained, "epoch=294-loss=0.654-main_score=0.349.ckpt"),
       }
   )
   

   注意

   .fit() 调用的字典键的命名是经过设计的。这些键在训练容器内部注册为带有 SM_CHANNEL_ 前缀的环境变量，可以在训练脚本中访问。键需要与 detector.py 文件中写入的内容匹配，以便使这个 .fit() 训练调用生效。例如，请参阅 detector.py 中的第 310 行和第 349 行：

   aa("--data-path", metavar="DIR", type=str, default=os.environ["SM_CHANNEL_TRAINING"])

   aa("--resume-sagemaker-from-checkpoint", type=str, default=os.getenv("SM_CHANNEL_PRETRAINED_CHECKPOINT", None))

训练完成后，模型作为 SageMaker 主机端点部署，如 0_demo.ipynb 笔记本中所示。最后，将真实值、从 0_demo.ipynb 预训练模型得到的推理结果以及微调模型的推理结果进行了可视化比较。我们可以看到，微调模型的推理结果少了一个误报，但仍然无法识别样本图像右侧的补丁。这应该被视为一个漏报。

1. 点击 2_detection_from_scratch.ipynb。

2. 运行 2_detection_from_scratch.ipynb 笔记本中的所有单元格。我们不是从检查点开始训练，而是使用相同的训练数据集从头开始训练一个模型，使用 10 个周期，并将推理结果与预训练模型的推理结果进行比较。由于使用了较小的周期数，模型训练不足，这是预期的。我们鼓励您将周期数（EPOCHS 变量）增加到 300 以获得更好的性能。然而，这将需要超过 10 分钟的时间。

   注意

   我们通过是否在字典中包含 pretrained_checkpoint 键来控制是否从检查点或从头开始训练。

3. 点击 3_classification_from_scratch.ipynb。

在这个笔记本中，我们使用classifier.py训练了一个分类模型，共进行了 50 个 epoch，而不是从头开始训练一个目标检测模型，使用了 NEU-CLS 分类数据集。分类模型与之前的目标检测模型不同。图像分类可以识别整个图像中的缺陷类型，而目标检测模型还可以定位缺陷的位置。如果你不需要知道缺陷的位置，图像分类非常有用，并且可以作为产品缺陷的分级模型使用。

从作业中可以看出，训练分类模型更快。正如训练作业的单元格输出所示，验证集上的分类准确率达到了0.99，这是一个非常准确的值：

Epoch 00016: val_acc reached 0.99219 (best 0.99219), saving model to /opt/ml/model/epoch=16-val_loss=0.028-val_acc=0.992.ckpt as top 1

1. 这就是解决方案的结束。请确保在每个笔记本中执行最后一个单元格以删除模型和端点，特别是0_demo.ipynb笔记本中的最后一个单元格，其中删除操作被注释掉了。请取消注释并执行它以删除预训练模型和端点。

使用这个 SageMaker JumpStart 解决方案，你基于 Faster RCNN 的 PyTorch 实现构建并训练了四个深度学习模型，以最小的编码工作量检测和分类钢图像中的六种缺陷类型。你还将它们作为 SageMaker 端点托管以进行实时预测。你可以期待在 SageMaker JumpStart 的其他解决方案中体验到类似的效果，以学习在解决常见用例时使用的 SageMaker 功能的各个方面。

现在，让我们转换到 SageMaker JumpStart 模型库。

SageMaker JumpStart 模型库

在 SageMaker JumpStart 中，有超过 200 个流行的预构建和预训练模型供你直接使用或继续训练以适应你的用例。它们有什么好处？训练一个准确的深度学习模型既耗时又复杂，即使是最强大的 GPU 机器也是如此。它还需要大量的训练和标记数据。现在，有了这些由社区开发、在大数据集上预训练的模型，你不必重新发明轮子。

模型集合

在 SageMaker JumpStart 模型库中有两组模型：文本模型和视觉模型。这些模型在机器学习社区中非常受欢迎。你可以快速浏览 SageMaker JumpStart 中的模型，并选择满足你需求的模型。在每一个模型页面上，你将看到该模型的介绍、用法以及如何为微调准备数据集。你可以将模型部署到 AWS 作为你的用例的托管端点，或者使用自己的数据集进一步微调模型。

文本模型来源于以下三个中心：TensorFlow Hub、PyTorch Hub 和 Hugging Face。每个模型都是针对特定类型的 NLP 任务使用如文本分类、问答或文本生成等数据集进行专门训练的。值得注意的是，有许多版本的双向编码器表示从 Transformer（BERT）、跨语言语言模型（XLM）、ELECTRA和生成预训练 Transformer（GPT）可供选择。

视觉模型来源于 TensorFlow Hub、PyTorch Hub 和 Gluon CV。这里有执行图像分类、图像特征向量提取和目标检测的模型。Inception、SSD、ResNet和Faster R-CNN模型是该领域最著名和最广泛使用的模型。

部署模型

让我们找到一个问答模型，看看我们如何将其部署到我们的 AWS 账户。在搜索栏中输入问答并按回车键，你应该会看到返回一个执行此类任务的模型列表，如图图 8.6所示。

图 8.6 – 搜索问答模型

让我们找到并双击OpenWebTextCorpus，它是由 RoBERTa 模型检查点提取的。它有 6 层，768 个隐藏单元，12 个头，和 8200 万个参数。8200 万个！训练这样一个大型模型当然不容易。幸运的是，有了 SageMaker JumpStart，我们可以直接部署一个模型。如图图 8.7所示，请展开部署配置部分，选择Ml.M5.Xlarge作为机器类型，将端点名称保留为默认值，然后点击部署。Ml.M5.Xlarge 是一种通用实例类型，具有 4 个 vCPU 和 16GB 的内存，这对于本例来说已经足够了。部署将需要几分钟。

图 8.7 – 部署 JumpStart DistilRoBERTa Base 模型

一旦模型部署完成，将提供一个笔记本，展示如何向托管端点发出 API 调用（如图图 8.8）。你可以在 JumpStart 的左侧侧边栏中找到模型列表。

图 8.8 – 部署模型后打开一个示例推理笔记本

在示例笔记本中，提供了来自SQuAD v2数据集的两个问题，这是最广泛使用的问答数据集之一，用于评估。让我们也根据以下段落（你能猜到你以前在哪里读过吗？是的，这是本章的开篇陈述！）向我们的模型提出其他问题：

上下文：

SageMaker JumpStart 作为入门套件，为世界各地的机器学习（ML）爱好者提供 Amazon SageMaker 的完整解决方案，无需任何代码开发。SageMaker JumpStart 还为您整理了流行的预训练计算机视觉（CV）和自然语言处理（NLP）模型，以便您轻松部署或微调到您的数据集。SageMaker Autopilot 是一个 AutoML 解决方案，它探索您的数据，代表您构建特征，并从各种算法和超参数中训练最优模型。您无需编写任何代码：Autopilot 会为您完成，并返回笔记本以展示它是如何做到的。

问题：

• SageMaker JumpStart 做什么？

• 什么是自然语言处理（NLP）？

在笔记本中，我们应该在第二个单元格中添加以下内容：

question_context3 = ["What does SageMaker JumpStart do?", "SageMaker JumpStart offers complete solutions for select use cases as a starter kit to the world of machine learning (ML) with Amazon SageMaker without any code development. SageMaker JumpStart also catalogs popular pretrained computer vision (CV) and natural language processing (NLP) models for you to easily deploy or fine-tune to your dataset. SageMaker Autopilot is an AutoML solution that explores your data, engineers features on your behalf and trains an optimal model from various algorithms and hyperparameters. You don't have to write any code: Autopilot does it for you and returns notebooks to show how it does it."]
question_context4 = ["What is NLP?", question_context3[-1]]

在第三个单元格中，将两个新的问题上下文对添加到 for 循环中的列表中，并执行笔记本中的所有单元格：

for question_context in [question_context1, question_context2, question_context3, question_context4]:

哇！我们从模型那里得到了回答，这些问题是关于 SageMaker JumpStart 的功能和自然语言处理（NLP）的全称。

微调模型

当您从架子上取下一个预训练模型，将其暴露于您的数据集，以便它在您的数据集上表现优于未暴露时的性能时，进行模型微调是典型的。此外，与从头开始训练模型相比，模型微调所需的时间更少，并且需要的标记数据量更小。要微调 SageMaker JumpStart 中的预训练模型，首先我们需要确保您想使用的模型支持微调。您可以在概述卡中找到此属性。其次，您需要将数据集指向模型。以 DistilRoBERTa Base 模型为例，SageMaker JumpStart 提供了默认的 SQuAD-v2 数据集，这允许您快速开始训练作业。您也可以按照 JumpStart 模型页面上的说明创建自己的数据集。我们就是要这样做。

让我们用关于佛教的一些问题和答案来微调基础 DistilRoBERTa Base 模型，佛教是 SQuAD-v2 数据集中的一个主题。请按照以下步骤操作：

1. 在存储库中打开 chapter08/1-prep_data_for_finetune.ipynb 笔记本，执行所有单元格以下载数据集，提取与佛教相关的段落，并按照微调训练器期望的方式组织它们。这在 data.csv 文件中的描述页上有详细说明：

   • data.csv 的第一列应该有一个问题。

   • 第二列应该有相应的上下文。

   • 第三列应该有答案在上下文中的整数字符起始位置。

   • 第四列应该有答案在上下文中的整数字符结束位置。

2. 输出：一个可以部署进行推理的训练模型。

3. 笔记本末尾，data.csv 文件将被上传到您的 SageMaker 默认存储桶：s3://sagemaker-<region>-<accountID>/chapter08/buddhism/data.csv。

4. 完成此操作后，让我们切换回模型页面并配置微调作业。如图 8.9 所示，将 -buddhism 添加到模型名称中，保留机器类型和超参数为默认值，然后点击 训练。默认的 Ml.P3.2xlarge 实例类型，配备一个 NVIDIA Tesla V100 GPU，是快速模型微调的一个很好的选择。默认的超参数设置使用 批量大小为 4、学习率为 2e-5 和 3 个训练轮数 进行微调。这对于我们演示微调的工作原理是足够的。您可以随意更改这里的值以反映您的实际使用情况。

图 8.9 – 为自定义数据集配置微调作业

使用 Ml.P3.2xlarge 实例，训练作业应该大约需要 6 分钟。

1. 作业完成后，您可以将模型部署到具有 Ml.M5.Xlarge 实例的端点，如图 8.10 所示。Ml.M5.Xlarge 是一种通用 CPU 实例，是模型托管的一个良好起点。

图 8.10 – 部署微调后的模型

当然，我们现在需要测试微调后的模型在涉及佛陀和佛教的问题上的表现。一旦部署完成，您将收到一个选项，可以打开一个预构建的笔记本来使用端点，类似于图 8.8 所示。

1. 我们可以将第二个单元格中的问题-上下文对替换为以下来自 www.history.com/topics/religion/buddhism 的片段：

   question_context1 = ["When was Buddhism founded?", "Buddhism is a faith that was founded by Siddhartha Gautama ("the Buddha") more than 2,500 years ago in India. With about 470 million followers, scholars consider Buddhism one of the major world religions. Its practice has historically been most prominent in East and Southeast Asia, but its influence is growing in the West. Many Buddhist ideas and philosophies overlap with those of other faiths."]
   question_context2 = ["Where is Buddhism popular among?", question_context1[-1]]
   

然后，执行笔记本中的单元格，您将看到我们的新模型表现如何。

这并不是我们希望模型达到的效果。这是由于使用了非常小的训练轮数，以及可能未优化的批量大小和学习率。由于我们为模型提供了新的数据点，网络中的权重再次更新，需要经过足够多的训练轮数以收敛到更低的损失，从而创建一个更准确的模型。这些超参数通常需要调整，以便即使在微调的情况下也能获得一个好的模型。我们鼓励您进一步实验不同的超参数，看看模型是否能够更好地回答问题。

我们刚刚创建了三个机器学习模型，这些模型应该是复杂且难以训练的，但几乎不需要编写任何代码。现在我们将学习如何使用 SageMaker Autopilot 自动创建一个高质量的模型，而无需任何代码。

使用 SageMaker Autopilot 创建高质量模型

你是否曾想过在没有数据预处理、特征工程、探索算法和优化超参数的麻烦的情况下构建机器学习模型？你是否曾想过，对于某些用例，你只是想快速看看机器学习是否是某个特定商业用例的可行方法？Amazon SageMaker Autopilot 使你能够轻松地为表格数据集构建机器学习模型，而无需任何代码。

葡萄酒质量预测

为了演示 SageMaker Autopilot，让我们使用葡萄酒质量预测用例。葡萄酒行业一直在寻找一种可以帮助酿酒师和市场更快、更标准地评估葡萄酒质量的技术。葡萄酒质量评估和认证是葡萄酒市场生产和销售的关键部分，并防止葡萄酒的非法掺假。葡萄酒评估由专家品酒师根据物理化学和感官测试进行，产生如密度、酒精水平和 pH 值等特征。然而，当涉及人类时，标准可能在品酒师之间或测试试验之间有所不同。因此，拥有一种机器学习方法来支持品酒师提供分析信息，在葡萄酒行业中成为一项重要任务。

我们将训练一个机器学习模型，根据 2004 年至 2007 年间在葡萄牙生产的 4,898 种白葡萄酒的物理化学感官值来预测葡萄酒质量。数据集可在 UCI 的 https://archive.ics.uci.edu/ml/datasets/Wine+Quality 处获得。

设置 Autopilot 作业

让我们开始吧：

1. 请打开存储库中的chapter08/2-prep_data_for_sm_autopilot.ipynb笔记本，并执行所有单元格以从源下载数据，保留测试集，并将训练数据上传到 S3 存储桶。请注意训练数据的路径。

2. 接下来，打开启动器并选择新建 Autopilot 实验，如图 8.11所示。

图 8.11 – 创建新的 Autopilot 实验

将弹出一个新窗口，供我们配置 Autopilot 作业。

1. 如图 8.12所示，提供white-wine-predict-quality。

图 8.12 – 配置 Autopilot 作业

1. 如图 8.12所示，从数据集文件名下拉菜单中选择sagemaker-<region>-<accountID>中的训练数据。将目标设置为quality，使用 CSV 文件中的其余属性来预测葡萄酒的质量。

2. 在配置页面的下半部分，如图 8.13 所示，提供保存输出数据的路径，将sagemaker-<region>-<accountID>从/sagemaker-studio-book/chapter08/winequality/路径检查到数据集目录名称字段中，作为输出位置。这个路径是我们训练 CSV 文件所在的位置。

![Figure 8.13 – 配置 Autopilot 作业

Figure 8.13 – 配置 Autopilot 作业

1. 如图 8.13 所示，从选择机器学习问题类型下拉菜单中选择多类分类。然后从目标指标下拉菜单中选择F1macro，以便在数据偏向某个质量等级时，我们可以期望得到一个更平衡的模型。

2. 如图 8.13 所示，对于您想运行完整实验吗？选择是。然后切换自动部署选项为关闭，因为我们希望在 SageMaker Studio 中走完评估过程后再部署我们的最佳模型。

3. 如图 8.13 所示，展开最大候选数字段中的100。默认情况下，Autopilot 运行 250 个具有不同预处理步骤、训练算法和超参数的训练作业。通过使用有限数量的候选者，我们应该期望完整实验比默认设置更快完成。

4. 点击创建实验以启动 Autopilot 作业。

您将看到一个新窗口，显示 Autopilot 作业的进度。请让它处理一下数字，过几分钟再回来。您将在进度标签中看到更多的进度和输出，如图 8.14 所示。

![Figure 8.14 – 查看 Autopilot 实验的进度

Figure 8.14 – 查看 Autopilot 实验的进度

这里有很多事情在进行中。让我们深入了解一下。

理解 Autopilot 作业

Amazon SageMaker Autopilot 自动执行端到端的机器学习模型构建练习。它执行探索性数据分析（EDA），进行数据预处理，并创建特征工程和模型训练配方。然后按照配方执行，以找到给定条件下的最佳模型。您可以在图 8.14 的中间部分查看进度。

使 Autopilot 独特的是它提供的全面可见性。Autopilot 通过提供 EDA 结果和 Autopilot 执行特征工程和机器学习建模的代码（以 Jupyter 笔记本的形式）来解包典型的 AutoML 黑盒。您可以通过点击打开数据探索笔记本按钮来访问 EDA 结果，以及点击打开候选生成笔记本按钮来访问配方。

数据探索笔记本有助于理解数据、分布以及 Autopilot 如何根据数据的特征构建食谱。例如，Autopilot 会在数据集中寻找缺失值、数值特征的分布以及分类特征的基数。这些信息为数据科学家提供了对数据的基准理解，以及关于输入数据是否包含合理条目的可操作见解。如果你看到许多特征具有高比例的缺失值（缺失值百分比部分），你可以采取建议的行动从数据创建的角度调查问题，并对特征进行一些预处理，要么删除特征，要么应用特定领域的插补。你可能想知道，“Autopilot 不是应用数据预处理和特征工程到数据上吗？”是的，它确实如此。然而，Autopilot 并不具备你数据的特定领域知识。你应该期待 Autopilot 对提出的问题采取更通用的、以数据科学为导向的方法，这可能不会那么有效。

候选生成笔记本规定了基于数据的 EDA（探索性数据分析）如何构建和训练模型的方法。代码的数量可能看起来令人畏惧，但如果你仔细阅读，你可以看到，例如，Autopilot 正在尝试的数据预处理步骤和建模方法，如候选管道部分所示。以下是一个例子：

The SageMaker Autopilot Job has analyzed the dataset and has generated 9 machine learning pipeline(s) that use 3 algorithm(s).

Autopilot 基于三种算法构建管道：XGBoost、线性学习器和多层感知器（MLP）。XGBoost 是一种流行的梯度提升树算法，以高效和灵活的方式结合了一组弱预测器来形成最终的预测器。XGBoost 是 SageMaker 内置算法之一。线性学习器也是一种 SageMaker 内置算法，它使用不同的超参数训练多个线性模型，并通过分布式随机梯度下降优化找到最佳模型。MLP 是一种基于神经网络的监督学习算法，它可以有多个隐藏层，以创建非线性模型。

你还可以看到 Autopilot 正在探索的超参数和范围列表（多算法超参数调整部分）。Autopilot 不仅提供了可见性，还给了你对实验的完全控制权。你可以点击右上角的导入笔记本按钮来获取一个你可以自定义并执行以获得下一个最佳模型的笔记本副本。

评估 Autopilot 模型

如果您在标签页中看到的工作状态，如图 8.14 所示，已更改为完成，那么就是时候评估自动驾驶仪生成的模型了。如您在试验列表中所见，自动驾驶仪已使用各种特征工程、算法和超参数的组合训练了 100 个模型。排行榜还显示了用于评估模型的性能指标，即随机验证分割上的 F1 分数。您可以通过点击目标：F1来按分数排序模型。

让我们更仔细地看看最佳模型，即具有最高 F1 分数且试验名称旁边有星号的模型。右键单击试验并选择在模型详情中打开以查看更多信息。

图 8.15 – 在 SageMaker Studio 中查看自动驾驶仪模型详情

自动驾驶仪在本页上报告了很多细节，如图 8.15 所示。首先，我们可以看到这个模型是基于XGBoost算法构建的。我们还看到了自动驾驶仪为我们生成的特征重要性图表。这个图表告诉我们模型如何考虑输入特征的重要性或贡献。自动驾驶仪使用SageMaker Clarify为这个 XGBoost 模型和数据集计算SHapley Additive exPlanations（SHAP）值。SHAP 值解释了特征如何根据博弈论对模型形成决策做出贡献。

注意

您可以将鼠标悬停在条形上以查看实际值。SageMaker 提供了更多细节，以便您可以在想了解更多？部分的白皮书中了解这些 SHAP 值是如何计算的。

返回图表，您还可以下载一个自动生成的包含此图表的 PDF 报告，以便审阅和分发（导出 PDF 报告）。如果您想以 JSON 格式处理原始数据以便在其他应用程序中集成 SHAP 值，您可以下载数据（下载原始数据）。通过点击这两个按钮，您将被重定向到如图 8.16 所示的 S3 控制台。您可以通过点击下载按钮从控制台上的 S3 存储桶下载文件。

图 8.16 – 在 S3 控制台中下载特征重要性 PDF 报告

除了特征重要性之外，模型在训练集和验证集上的表现对于理解模型在实际生活中的表现同样非常重要。您可以在用于在排行榜上对模型进行排名的ObjectiveMetric中看到训练运行期间捕获的指标，我们看到了以下指标：

• train:f1

• train:merror

• validation:f1

• validation:merror

它们是多类 F1 宏度量以及数据训练和验证分割的多类错误。正如你可以通过相同的值所知，ObjectiveMetric基本上等同于validation:f1。由于train:f1远高于validation:f1，我们可能会得出结论，该模型过度拟合了训练数据集。但为什么会这样呢？

我们可以使用我们在一开始就保留的测试数据进一步详细验证模型性能。请从存储库中打开chapter08/3-evaluate_autopilot_models.ipynb笔记本，并执行所有单元格。在这个笔记本中，你将根据ObjectiveMetric从 Autopilot 作业中检索顶级模型，使用TOP_N_CANDIDATES在云中进行推理，针对不同的数量。你应该会看到计算出的 F1 分数，包括宏度量、未加权平均值、加权方法、分类报告（来自 sklearn 函数）和测试数据上的混淆矩阵，这是最后一个单元格的输出。

使用顶级模型时，这里有几个方面让我印象深刻。数据在本质上是不平衡的。分数为5、6和7的葡萄酒数量较多。很少有葡萄酒得到3、4或8的分数。混淆矩阵还显示，得到3分的葡萄酒都被错误分类了。在这种情况下，由于对少数类的错误分类不成比例，f1宏度量将大幅降低。如果我们查看f1得分的加权版本，我们会得到一个显著更高的分数，因为评分更重视主导类：

Candidate name:  white-wine-predict-qualitysZ1CBE-003-1a47413b
Objective metric name:  validation:f1
Objective metric value:  0.4073199927806854
f1 = 0.51, Precision = 0.59 (macro)
f1 = 0.67, Precision = 0.68 (weighted)
              precision    recall  f1-score   support
           3       0.00      0.00      0.00         3
           4       0.70      0.39      0.50        18
           5       0.63      0.67      0.65       144
           6       0.67      0.77      0.72       215
           7       0.76      0.57      0.65        94
           8       0.78      0.44      0.56        16
    accuracy                           0.67       490
   macro avg       0.59      0.47      0.51       490
weighted avg       0.68      0.67      0.67       490
[[  0   0   3   0   0   0]
 [  0   7   8   3   0   0]
 [  0   2  96  45   1   0]
 [  0   1  37 166  10   1]
 [  0   0   8  31  54   1]
 [  0   0   0   3   6   7]]

使用对用例最重要的度量来衡量模型性能也很重要。正如被引用研究的作者关于精确度度量重要性的陈述：

"这个统计量在实践中很重要，因为在实际的部署设置中，实际值是未知的，并且给定列内的所有预测都会被同等对待。"

我们应该比较原始研究研究中使用的精确度度量（在研究中的表 3，在进一步阅读部分中链接），其中个体精确度如下：

• 4: 63.3%

• 5: 72.6%

• 6: 60.3%

• 7: 67.8%

• 8: 85.5%

当对白葡萄酒的容忍度T = 0.5时。我们的第一个 Autopilot 模型在某些类别中精确度表现优异，而在其他类别中表现不佳。

另一种找到更适合业务问题的模型的方法是评估更多模型，而不仅仅是 Autopilot 建议的最佳模型。我们可以看到另外两个（或更多，取决于您对 TOP_N_CANDIDATES 的设置）的评估。我们发现，尽管第二和第三个模型的 validation:f1（宏）分数低于第一个模型，但它们在保留的测试集上的 F1 分数实际上更高。第三个模型的个别精确度分数都优于原始研究中的模型，除了第 5 类，高出 2.6%。多么迷人！排行榜中的第三个模型在测试数据上的表现（按精确度指标衡量）实际上更好，这对于用例来说最有意义。

评估后，我们可以将最佳模型部署到端点进行实时推理。Autopilot 使得部署模型变得简单。在排行榜中，选择您想要部署的项目，然后点击部署模型按钮。将弹出一个新页面，供您配置端点。对于经验丰富的 SageMaker Studio 用户来说，大多数选项都是直观且不言自明的。有两点需要注意：您可以选择启用数据捕获，这在您想设置 SageMaker 模型监控器时很有用。如果您希望模型返回的不仅仅是预测标签，例如在多类用例中获胜类的硬标签，您可以选择返回获胜标签的概率、所有类的标签和所有类的概率。选择顺序也将决定输出顺序。

摘要

在本章中，我们介绍了集成到 SageMaker Studio 的两个功能——JumpStart 和 Autopilot，以及三个机器学习用例，以展示为机器学习开发者提供的低代码到无代码的机器学习选项。我们学习了如何在目录中浏览 JumpStart 解决方案，以及如何从 JumpStart 部署端到端的计算机视觉解决方案以检测产品缺陷。我们还使用 JumpStart 模型动物园中的 DistilRoBERTa Base 模型部署并微调了一个问答模型，而无需任何机器学习编码。使用 Autopilot，我们只需将 Autopilot 指向存储在 S3 中的数据集并启动一个 Autopilot 作业，就可以简单地构建一个白葡萄酒质量预测模型——无需编写代码。结果证明，Autopilot 的表现甚至超过了原始研究人员可能花费数月时间创建的模型。

在下一章中，我们开始本书的下一部分：使用 SageMaker Studio 的机器学习生产与操作。我们将学习如何通过 SageMaker 的分布式训练从原型设计过渡到大规模的机器学习训练，如何使用 SageMaker Debugger 轻松监控模型训练，以及如何通过托管 Spot 训练节省训练成本。

进一步阅读

想要了解更多信息，请查看以下资源：

• P. Cortez, A. Cerdeira, F. Almeida, T. Matos 和 J. Reis. 通过数据挖掘物理化学性质建模葡萄酒偏好。载于《决策支持系统》，Elsevier，第 47 卷第 4 期，第 547-553 页，2009 年。bit.ly/3enCZUz

第三部分 – 使用 SageMaker Studio 的机器学习生产与运营

在本节中，您将学习如何有效地使用 SageMaker Studio 规模化并操作化机器学习（ML）的生命周期，以便您可以减少数据科学家所需进行的手动和非区分性工作，并让他们专注于建模。

本节包括以下章节：

• 第九章, 在 SageMaker Studio 中大规模训练机器学习模型

• 第十章, 使用 SageMaker 模型监控在生产中监控机器学习模型

• 第十一章, 使用 SageMaker Projects、Pipelines 和模型注册表实现机器学习项目的操作化

第九章：在 SageMaker Studio 中大规模训练机器学习模型

一个典型的机器学习生命周期从原型设计开始，将过渡到生产规模，数据量增大，模型变得更加复杂，运行环境也更加复杂。完成训练作业需要正确的一套工具。使用多台计算机进行分布式训练以分担负载，可以解决涉及大量数据集和大型模型的情况。然而，随着复杂的机器学习训练作业使用更多的计算资源，以及更昂贵的硬件基础设施（如图形处理单元（GPU）），对于数据科学家和机器学习工程师来说，能够在大量数据上有效地训练复杂的机器学习模型非常重要。能够查看和监控训练脚本如何与数据和计算实例交互，对于优化训练脚本中的模型训练策略，使其既节省时间又节省成本至关重要。当在大规模训练时谈到成本，您知道您可以在 SageMaker 中轻松地节省超过 70%的费用吗？SageMaker Studio 使得大规模训练机器学习模型变得更加容易且成本效益更高。

在本章中，我们将学习以下内容：

• 在 SageMaker Studio 中执行分布式训练

• 使用 SageMaker Debugger 监控模型训练和计算资源

• 使用检查点和 spot 训练管理长时间运行的作业

技术要求

对于本章，您需要访问提供的代码，链接为github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter09。

在 SageMaker Studio 中执行分布式训练

随着深度学习领域的进步，机器学习模型和训练数据增长到一个点，单个设备已不再足以进行有效的模型训练。神经网络变得越来越深，训练参数也越来越多：

• LeNet-5，这是 1989 年提出的第一个卷积神经网络（CNN）模型之一，使用了 2 个卷积层和 3 个密集层，大约有 6 万个可训练参数。

• AlexNet，这是一种在 2012 年提出的具有 5 层卷积层和 3 个密集层的更深层 CNN 架构，大约有 6200 万个可训练参数。

• 双向 Transformer 语言理解模型（BERT），这是一种在 2018 年提出的基于 transformer 的语言表示模型，其基础模型和大模型分别有 1.1 亿和 3.4 亿可训练参数。

• 生成式预训练 Transformer 2（GPT-2），这是一种在 2019 年提出的基于大型 transformer 的生成模型，拥有 15 亿可训练参数。

• GPT-3是下一个版本，于 2020 年提出，其可训练参数达到 1750 亿。

有更多参数需要训练意味着在训练期间有更大的内存占用。此外，适应复杂模型所需训练数据的大小也显著增加。对于计算机视觉，最常用的训练数据集之一 ImageNet 有 120 万张图片。例如，对于自然语言处理（NLP），GPT-3 的训练使用了 4990 亿个标记。

然而，最新的最强大的 GPU 设备在满足这样的训练需求时仍会感到吃力。来自 NVIDIA 的最新 GPU 设备，AWS P4d.24xlarge 实例上的 A100 Tensor Core GPU，有 40GB 的 GPU 内存，但它不足以容纳拥有 1750 亿个参数的 GPT-3 模型，因为这样的网络在使用FP32精度时需要175 x 10⁹ x 4 bytes = 700GB。因此，开发者正在超越单 GPU 设备训练，并求助于分布式训练——即使用多个 GPU 设备和多个计算实例进行训练。

让我们了解为什么以及如何分布式训练有助于。

理解分布式训练的概念

在机器学习模型训练中，训练数据被输入到损失优化过程中，以计算下一步的梯度和权重。当数据和相关参数很大，如深度学习的情况时，由于设备上的 GPU 内存限制，拥有一个适合优化的完整数据集变得不太可行。通常使用随机梯度下降优化方法，该方法在每一步中用完整训练数据集的子集（批大小）估计梯度，以克服 GPU 内存限制。然而，当模型或每个数据点太大，以至于无法为模型训练提供一个有意义的批大小时，我们无法在合理的时间内收敛到一个最优、准确的模型。

分布式训练是一种将计算的部分分布到多个 GPU 设备和多个计算实例（也称为节点）的实践，并在进行下一次迭代之前同步所有设备的计算。分布式训练中有两种策略：数据并行和模型并行。

数据并行在训练周期中将训练数据集从磁盘分布到多个设备和实例，每个设备包含数据的一部分和模型的完整副本。每个节点使用不同的数据批次执行正向和反向传播，并在传播结束时与其他节点共享可训练权重的更新以进行同步。使用数据并行，你可以将批大小增加n倍，其中n是节点间 GPU 设备的数量。一个适当大的批大小在估计梯度期间允许更好的泛化，并且也减少了运行整个传播（一个周期）所需的步骤数量。

注意

实践中观察到，过大的批次大小会损害模型的质量和泛化能力。这取决于模型和数据集，需要实验和调整来找到合适的批次大小。

数据并行在图 9.1中展示：

![img/B17447_09_001.jpg]

图 9.1 – 在数据并行中，训练数据被分布到 GPU 设备上。模型的完整副本放置在每个 GPU 设备上

另一方面，模型并行将大型模型分布到节点上。模型的分割在层和权重级别上进行。每个节点拥有模型的一部分。前向和反向传播作为一个流水线进行，数据批次在所有节点上的模型分割中通过，然后在权重更新之前。更具体地说，每个数据批次被分成微批次，并输入到每个模型部分，这些部分位于用于前向和反向传播的设备上。使用模型并行，你可以更有效地训练需要比单个 GPU 设备更高的 GPU 内存占用的大型模型，通过从多个 GPU 设备中集体使用内存。模型并行在图 9.2中展示：

![img/B17447_09_002.jpg]

图 9.2 – 在模型并行中，模型被分割到多个 GPU 设备上。训练数据被分成微批次并输入到 GPU 中，每个 GPU 拥有模型的一部分作为流水线

我们应该在什么情况下使用数据并行或模型并行？ 这取决于训练中的数据大小、批次和模型大小。当单个数据点太大，在训练期间无法达到期望的批次大小时，数据并行是合适的。小批次大小的直接权衡是完成一个 epoch 需要更长的时间。你可能希望增加批次大小，以便在合理的时间内完成一个 epoch。你可以使用数据并行将更大的批次大小分布到多个 GPU 设备上。然而，如果你的模型很大，并且在一个设备上占据了大部分 GPU 内存，你将不会从数据并行中获得太多的规模效益。这是因为，在数据并行中，ML 模型被完全复制到每个 GPU 设备上，留给数据的空间很少。当你的模型相对于 GPU 内存很大时，你应该使用模型并行。

SageMaker 使得在云中运行大型数据集和大型模型的分布式训练变得简单。当在 SageMaker 中使用时，SageMaker 的 分布式训练库 支持数据并行和模型并行，适用于最流行的两个深度学习框架，TensorFlow 和 PyTorch。SageMaker 的 分布式数据并行库 以接近线性的扩展效率扩展您的模型训练，这意味着与节点数量相关的训练时间减少接近线性。SageMaker 的 分布式模型并行库 自动分析您的神经网络架构，并将模型分割到 GPU 设备上，并高效地编排管道执行。

在以下章节中，我们将学习如何在 SageMaker Studio 中实现数据并行和模型并行，适用于我们用 TensorFlow 和 PyTorch 编写的训练脚本。

注意

TensorFlow 和 PyTorch 都由两个分布式训练库支持。这两个深度学习框架之间的分布式训练概念是相同的。我们将重点关注 TensorFlow 的数据并行库和 PyTorch 的模型并行库。

TensorFlow 的数据并行库

SageMaker 的分布式数据并行库实现了类似于 TensorFlow 以分布式方式执行模型训练的简单 API，但进行了针对 AWS 计算基础设施优化的分布式训练。这意味着您可以在不修改现有用 TensorFlow 编写的分布式训练代码的情况下轻松采用 SageMaker 的 API。如果您这是第一次进行分布式模型训练，我们将演示如何修改以适应 SageMaker 的分布式数据并行库到现有的模型训练脚本。

让我们去 SageMaker Studio 并开始使用 Getting-Started-with-Amazon-SageMaker-Studio/chapter09/01-smdp_tensorflow_sentiment_analysis.ipynb 笔记本。这个示例是基于我们在 第五章，使用 SageMaker Studio IDE 构建和训练 ML 模型中走过的训练示例构建的，在那里我们使用 TensorFlow Keras API 在 IMDB 评论数据集上训练了一个深度学习模型。回到 第五章，使用 SageMaker Studio IDE 构建和训练 ML 模型，我们在一个 ml.p3.2xlarge 实例上运行了训练脚本，该实例只有一个 NVIDIA Tesla V100 GPU。现在，在本章中，我们将使用 SageMaker 的分布式数据并行库来扩展代码，使其能够与多个 GPU 设备一起工作，无论是来自单个实例还是多个实例。记住，我们总可以在 sagemaker.tensorflow.TensorFlow 估算器中轻松指定实例数量和实例类型。让我们打开笔记本，选择 %%writefile code/smdp_tensorflow_sentiment.py，这是修改以采用分布式训练脚本的地方。按照以下步骤查看需要进行的更改，以启用分布式数据并行库：

1. 首先，导入数据并行库的 TensorFlow 模块：

   import smdistributed.dataparallel.tensorflow as sdp
   

2. 在导入库之后，我们需要初始化 SageMaker 分布式数据并行库以便在运行时使用。我们可以在 import 语句之后或 main 函数（if __name__ == "__main__"）中实现它：

   sdp.init()
   

3. 然后，我们发现了计算实例集群中所有可用的 GPU 设备，并配置了 GPU，使它们了解实例内的排名。如果一个实例有八个 GPU 设备，每个设备都将被分配一个从零到七的排名。可以这样理解：每个 GPU 设备都会建立一个进程来运行脚本，并通过 sdp.local_rank() 获得一个唯一的排名：

   gpus = tf.config.experimental.list_physical_devices('GPU')
   if gpus:
       local_gpu = gpus[sdp.local_rank()]
       tf.config.experimental.set_visible_devices(local_gpu, 'GPU')
   

4. 我们还配置了 GPU 以允许内存增长。这是在运行 TensorFlow 与 SageMaker 分布式数据并行库时特有的：

   for gpu in gpus:
       tf.config.experimental.set_memory_growth(gpu, True)
   

计算环境现在已准备好执行分布式训练。

1. 我们通过设备数量来缩放学习率。由于数据并行，我们将能够适应更大的批量大小。随着批量大小的增加，建议按比例缩放学习率：

   args.learning_rate = args.learning_rate * sdp.size()
   

2. 在之前的第五章，“使用 SageMaker Studio IDE 构建和训练 ML 模型”中，我们使用 Keras 的model.fit() API 训练了模型，但我们必须对模型训练做一些修改。SageMaker 的分布式数据并行库尚不支持 Keras 的.fit() API，只与 TensorFlow 核心模块一起工作。要使用 SageMaker 的分布式数据并行库，我们可以使用 TensorFlow 2.x 的自动微分（tf.GradientTape）和急切执行。在get_model()函数中使用 Keras 层定义模型后，我们不再用优化器编译它，而是用loss函数、优化器和显式定义的准确率度量来明确编写正向和反向传递：

   model = get_model(args)
   loss = tf.losses.BinaryCrossentropy(name = 'binary_crossentropy')
   acc = tf.metrics.BinaryAccuracy(name = 'accuracy')
   optimizer = tf.optimizers.Adam(learning_rate = args.learning_rate)
   with tf.GradientTape() as tape:
       probs = model(x_train, training=True)
       loss_value = loss(y_train, probs)
       acc_value = acc(y_train, probs)
   

然后，我们将tf.GradientTape包装在 SMDataParallel 的DistributedGradientTape中，以优化多 GPU 训练期间的AllReduce操作。AllReduce是一个将所有分布式进程的矩阵进行归约的操作：

tape = sdp.DistributedGradientTape(tape, sparse_as_dense = True)

注意，sparse_as_dense参数设置为True，因为我们模型中有一个嵌入层，它将生成稀疏矩阵。

1. 在训练开始时，从主节点（rank 0）广播初始模型变量到所有其他工作节点（rank 1及以后）。我们使用first_batch变量表示训练 epoch 的开始：

   if first_batch:
       sdp.broadcast_variables(model.variables, root_rank=0)
       sdp.broadcast_variables(optimizer.variables(), root_rank=0)
   

2. 在设备间平均损失和准确率；这个过程称为all-reduce：

   loss_value = sdp.oob_allreduce(loss_value)
   acc_value = sdp.oob_allreduce(acc_value)
   

3. 将这些步骤放入training_step()函数中，以执行正向和反向传递，并用@tf.function装饰。在嵌套的for循环中运行此训练步骤，遍历训练数据的 epoch 和批次。我们需要确保在传递过程中所有 GPU 设备都获得相等的数据量。我们通过在内层for循环中取可被 GPU 设备总数整除的数据来实现这一点：

   train_dataset.take(len(train_dataset)//sdp.size())
   

4. 在训练epoch循环之后，我们只使用主设备保存模型：

   if sdp.rank() == 0:
       model.save(os.path.join(args.model_dir, '1'))
   

5. 在训练脚本中，最后但同样重要的是，我们将训练数据转换为tf.data.Dataset对象，并在get_train_data()函数中设置批处理，以便与我们的急切执行实现一起工作。请注意，我们需要drop_remainder来防止数据集在设备间具有相等的批处理大小：

   dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
   dataset = dataset.batch(batch_size, drop_remainder=True)
   

6. 然后，我们转向 SageMaker 的 TensorFlow 估算器构建。为了在训练作业中启用 SageMaker 分布式数据并行库，我们需要提供一个字典：

   distribution = {'smdistributed': {'dataparallel': {'enabled': True}}}
   

这被分配给估算器，如下所示。

train_instance_type = 'ml.p3.16xlarge'
estimator = TensorFlow(source_dir='code',
     entry_point='smdp_tensorflow_sentiment.py',
     ...
     distribution=distribution)

此外，我们还需要从以下实例类型中选择一个支持 SageMaker 分布式数据并行库的 SageMaker 实例：ml.p4d.24xlarge、ml.p3dn.24xlarge和ml.p3.16xlarge：

1. ml.p4d.24xlarge实例配备了 8 个 NVIDIA A100 Tensor Core GPU，每个 GPU 拥有 40 GB 的 GPU 内存。

2. ml.p3dn.24xlarge实例配备了 8 个 NVIDIA Tesla V100 GPU，每个 GPU 拥有 32 GB 的 GPU 内存。

3. ml.p3.16xlarge实例还配备了 8 个 NVIDIA Tesla V100 GPU，每个 GPU 具有 16 GB 的 GPU 内存。

为了演示目的，我们将选择 ml.p3.16xlarge，这是三种选项中最便宜的一个。一个单独的 ml.p3.16xlarge 就足以在 SageMaker 中运行分布式数据并行训练，因为将有 8 个 GPU 设备来执行训练。

由于有更多的 GPU 设备和 GPU 内存可以在一个 epoch 中进行批处理，我们现在可以增加batch_size。我们将batch_size从我们在第五章中使用的值扩大了 8 倍，即64 x 8 = 512。

1. 使用估计器，我们可以继续调用estimator.fit()来开始训练。

要验证训练是否在多个 GPU 设备上运行，最简单的方法是查看标准输出。您可以看到添加了前缀[x, y]<stdout>: message，以指示产生消息的进程等级，如图9.3所示。我们将在使用 SageMaker Debugger 监控模型训练和计算资源部分中了解更多关于这个主题的内容：

![图 9.3 – 单元的标准输出，显示从进程等级[1,0]到[1,7]打印的消息。在我们的示例中，我们使用了一个具有八个 GPU 设备的 ml.p3.16xlarge 实例

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/gtst-amz-sgmkr-std/img/B17447_09_003.jpg)

图 9.3 – 单元的标准输出，显示从进程等级[1,0]到[1,7]打印的消息。在我们的示例中，我们使用了一个具有八个 GPU 设备的 ml.p3.16xlarge 实例

尽管在这里我没有使用 PyTorch 来演示 SageMaker 的分布式数据并行库，但 PyTorch 确实在smdistributed.dataparallel.torch模块下得到了库的支持。此模块提供了一套与 PyTorch 原生分布式数据并行库相似的 API。这意味着您不需要进行很多编码更改，就可以将 SageMaker 的分布式数据并行库用于 PyTorch，该库针对使用 SageMaker 基础设施的训练进行了优化。您可以在docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-modify-sdp-pt.html上找到有关如何在 PyTorch 脚本中采用它的更多详细信息。

在下一节中，我们将运行一个 PyTorch 示例并采用模型并行性。

PyTorch 的模型并行性

模型并行性在您有一个大型网络模型且无法适应单个 GPU 设备内存时特别有用。SageMaker 的分布式模型并行库实现了两个功能，这些功能使得对大型模型的训练变得高效，因此您可以轻松地将库适配到现有的训练脚本中：

• 自动模型分区，这最大化了 GPU 利用率，平衡了内存占用，并最小化了 GPU 设备之间的通信。相比之下，您也可以使用库手动分区模型。

• 流水线执行，它决定了不同 GPU 设备上的模型不同部分之间的计算和数据移动的顺序。有两种流水线实现：交错和简单。交错流水线尽可能优先处理反向传递。它更有效地使用 GPU 内存，并最小化整个 GPU 设备队列中任何 GPU 设备的空闲时间，无需等待前向传递完成就开始反向传递，如图 9.4 所示：

图 9.4 – 在两个 GPU（GPU0 和 GPU1）上的交错流水线。F0 代表第一个微批次的正向传递，B1 代表第二个微批次的反向传递。尽可能优先处理反向传递

另一方面，简单的流水线会在开始反向传递之前等待前向传递完成，从而产生一个更简单的执行计划，如图 9.5 所示：

图 9.5 – 在两个 GPU 上的简单流水线。只有在前向传递完成后才会运行反向传递

注意

图 9.4和9.5中的图像来自：docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html

让我们从chapter09/02-smmp-pytorch_mnist.ipynb中的笔记本开始一个示例，我们将应用 SageMaker 的分布式模型并行库来训练一个 PyTorch 模型，使用著名的 MNIST 数字数据集对数字手写体进行分类。在 SageMaker Studio 中打开笔记本并使用ml.t3.medium实例：

1. 如同往常，在第一个单元中设置 SageMaker 会话并导入依赖项。

2. 然后，创建一个用 PyTorch 编写的模型训练脚本。这是一个新的训练脚本。本质上，它是在torchvision库的 MNIST 手写数字数据集上训练卷积神经网络模型。模型使用torch.nn模块定义。使用的优化器是 AdamW 优化算法。我们实现了训练周期和批处理，因为它允许我们最大限度地灵活地采用 SageMaker 的分布式模型并行库。

3. SageMaker 的 PyTorch 分布式模型并行库可以从smdistributed.modelparallel.torch导入：

   import smdistributed.modelparallel.torch as smp
   

4. 导入库后，初始化 SageMaker 分布式模型并行库以便在运行时使用。我们可以在导入语句之后或main（if __name__ == "__main__"）中实现它：

   smp.init()
   

5. 我们将 ping 并设置 GPU 设备及其本地排名：

   torch.cuda.set_device(smp.local_rank())
   device = torch.device('cuda')
   

6. 从torchvision下载数据的过程应该只在主节点（local_rank = 0）上进行，而所有其他进程（在其他 GPU 上）应该等待主节点完成下载：

   if smp.local_rank() == 0:
       dataset1 = datasets.MNIST('../data', train=True, 
                     download=True, transform=transform)        
   smp.barrier() # Wait for all processes to be ready
   

7. 然后，使用 SageMaker 的分布式模型并行库的实现来包装模型和优化器：

   model = smp.DistributedModel(model)
   optimizer = smp.DistributedOptimizer(optimizer)
   

到目前为止，SageMaker 的分布式数据并行库和模型并行库之间的实现相当相似。以下是在模型并行库中有所不同之处。

1. 我们为函数的前向和反向传递创建一个train_step()，并用@smp.step装饰它：

   @smp.step
   def train_step(model, data, target):
       output = model(data)
       loss = F.nll_loss(output, target, reduction='mean')
       model.backward(loss)
       return output, loss
   

创建另一个train()函数以在 epoch 内实现批处理。这是我们调用train_step()以对一批数据进行前向和反向传递的地方。重要的是，需要在train_step()之前放置与数据相关的to.(device)调用，而通常不需要model.to(device)。将模型放置到设备上是由库自动完成的。

在进入下一个批次之前，我们需要使用.reduce_mean()对微批次中的损失进行平均。此外，请注意optimizer.step()需要在train_step()外部执行：

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        _, loss_mb = train_step(model, data, target)
        # Average the loss across microbatches.
        loss = loss_mb.reduce_mean()
        optimizer.step()

1. 实现test_step()，用@smp.step装饰，并类似地为模型评估实现test()。这允许在模型评估中也实现模型并行。

2. 在 epochs 循环之后，使用smp.dp_rank()==0保存模型以避免数据竞争并确保正确收集。注意，如果我们想以后能够加载模型并进一步训练它，我们需要设置partial=True：

   if smp.dp_rank() == 0:
       model_dict = model.local_state_dict()
       opt_dict = optimizer.local_state_dict()
       model = {'model_state_dict': model_dict, 'optimizer_state_dict': opt_dict}
       model_output_path = f'{args.model_dir}/pt_mnist_checkpoint.pt'
       smp.save(model, model_output_path, partial=True)
   

3. 然后，我们继续到 SageMaker PyTorch 估计器构建。为了在训练作业中启用 SageMaker 的分布式模型并行库，我们需要提供一个配置 SageMaker 的分布式模型并行库的字典，以及'partitions': 2以优化模型分区速度，'optimize': 'speed'，使用包含四个样本的微批处理'microbatches': 4，采用交错流水线调度（'pipeline': 'interleaved'），并禁用分布式数据并行'ddp': False。MPI 通过每个主机四个进程启用'mpi':{'enabled': True, 'processes_per_host': 2}}，这应该小于或等于 GPU 设备数量：

   distribution = {'smdistributed': {
                       'modelparallel': {
                           'enabled': True,
                           'parameters': {
                               'partitions': 2,
                                'optimize': 'speed',
                               'microbatches': 4,
                               'pipeline': 'interleaved',
                               'ddp': False
                           }
                       }
                   },
                   'mpi': {
                       'enabled': True,
                       'processes_per_host': 2
                   }
               }
   

你可以在sagemaker.readthedocs.io/en/stable/api/training/smd_model_parallel_general.html#smdistributed-parameters找到distribution的完整参数列表。

1. 然后，将distribution字典应用于 PyTorch 估计器，并使用一个 ml.p3.8xlarge 实例，该实例具有四个 NVIDIA Tesla V100 GPU。与 SageMaker 的分布式数据并行库不同，SageMaker 的分布式模型并行库支持所有具有多个 GPU 设备的实例。

2. 然后，我们可以继续调用estimator.fit()以开始训练。

采用 SageMaker 的分布式模型并行库的 TensorFlow 训练脚本采用了类似的概念，我们可以轻松地了解这些概念。你可以在docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-customize-training-script-tf.html#model-parallel-customize-training-script-tf-23了解更多关于如何使用smdistributed.modelparallel.tensorflow模块的信息。

当使用多个 GPU 设备进行训练时，主要挑战之一是理解 GPU 资源是如何被利用的。在下一节中，我们将讨论 SageMaker Debugger，这是一个帮助我们分析 SageMaker 训练作业期间计算资源利用情况的特性。

使用 SageMaker Debugger 监控模型训练和计算资源

使用sagemaker.estimator.Estimator和相关类，如sagemaker.pytorch.estimator.PyTorch和sagemaker.tensorflow.estimator.TensorFlow进行 ML 模型训练，为我们提供了在 SageMaker Studio 中开发所需的灵活性和可扩展性。然而，由于使用了远程计算资源，与在本地机器或单个 EC2 机器上调试和监控训练作业相比，SageMaker Studio 笔记本上的调试和监控训练作业有很大的不同。作为一个 ML IDE，SageMaker Studio 通过SageMaker Debugger提供了对托管训练作业的全面视图。SageMaker Debugger 帮助开发者监控计算资源利用率，检测建模相关的问题，分析深度学习操作，并在训练作业运行时识别瓶颈。

SageMaker Debugger 支持 TensorFlow、PyTorch、MXNet 和 XGBoost。默认情况下，SageMaker Debugger 在每一个 SageMaker 估计器中都是启用的。它每 500 毫秒收集实例指标，如 GPU、CPU 和内存利用率，每 500 步收集基本的张量输出，如损失和准确率。数据保存在你的 S3 桶中。你可以在 SageMaker Studio IDE 中实时检查监控结果或作业完成后进行检查。你还可以将监控结果从 S3 检索到笔记本中，并运行额外的分析和自定义可视化。如果默认设置不够用，你可以通过编程方式配置 SageMaker Debugger，为你的Estimator获取所需的信息级别。

要开始，我们可以首先检查我们在Machine-Learning-Development-with-Amazon-SageMaker-Studio/chapter09/01-smdp_tensorflow_sentiment_analysis.ipynb中运行的作业的默认 Debugger 配置信息：

1. 找到你已运行的作业名称。它在jobname变量中，形式为imdb-smdp-tf-YYYY-mm-DD-HH-MM-SS。你也可以在最后一个单元的输出中找到它。

2. 导航到jobname；双击条目。您将看到一个名为训练的试验组件，如图图 9.6所示。右键单击条目并选择打开调试器以获取洞察：

![图 9.6 – 从实验和试验中打开 SageMaker 调试器 UI

![img/B17447_09_006.jpg]

图 9.6 – 从实验和试验中打开 SageMaker 调试器 UI

1. 在主工作区域将弹出一个新窗口。该窗口将在几分钟内可用，因为 SageMaker Studio 正在启动一个专用实例来处理和渲染 UI 中的数据。这被称为SageMaker 调试器洞察仪表板。一旦可用，您可以在概览和节点选项卡中查看结果，如图图 9.7所示：

![图 9.7 – 显示训练过程中 CPU 和网络利用率的 SageMaker 调试器洞察仪表板

![img/B17447_09_007.jpg]

图 9.7 – 显示训练过程中 CPU 和网络利用率的 SageMaker 调试器洞察仪表板

在节点选项卡中，图表显示了 CPU、网络、GPU 和 GPU 内存的平均利用率。您可以将图表缩小到特定的 CPU 或 GPU，以查看设备之间是否存在不均匀的利用率，如图图 9.8所示。从这些图表中，我们可以得出以下结论：

• 平均 CPU 利用率在作业开始后大约 3 分钟达到峰值，约为 60%。这表明训练正在进行，CPU 端有大量活动来读取数据批次并将其输入到 GPU 设备中。

• 在八台设备上的平均 GPU 利用率在作业开始后大约 3 分钟达到峰值，约为 25%。同时，平均使用了大约 5%的 GPU 内存。这被认为是低 GPU 利用率，可能是由于与现在更大的计算能力相比，批次大小较小。

• 另一方面，在前 3 分钟内有一些网络利用率。这是 SageMaker 的完全管理训练从 S3 存储桶下载训练数据的时期：

![图 9.8 – 显示训练过程中 GPU 利用率的 SageMaker 调试器洞察仪表板

![img/B17447_09_008.jpg]

图 9.8 – 显示训练过程中 GPU 利用率的 SageMaker 调试器洞察仪表板

在页面底部，显示了一个 CPU/GPU 利用率的整体热图。作为练习，您可以随意打开在Getting-Started-with-Amazon-SageMaker-Studio/chapter06/02-tensorflow_sentiment_analysis.ipynb提交的训练作业的调试器，并比较单设备训练和分布式训练之间 CPU/GPU 利用率的差异。

接下来，我们将学习如何在 SageMaker Studio 中使用完全管理的 spot 训练降低训练 ML 模型的成本，以及如何为长时间运行的工作和 spot 工作创建检查点。

使用检查点和 spot 训练管理长时间运行的任务

在大规模上训练机器学习模型可能会很昂贵。即使在 SageMaker 的按需付费定价模型下，进行长时间运行的深度学习训练和使用多个昂贵的实例也会迅速增加成本。SageMaker 的完全托管式 spot 训练和检查点功能使我们能够轻松管理和恢复长时间运行的任务，帮助我们将训练实例的成本降低高达 90%，与按需实例相比。

SageMaker 管理的 Spot 训练使用了 Amazon EC2 的 spot 实例概念。EC2 的 spot 实例允许你以比常规按需实例低得多的成本利用 AWS 区域中任何未使用的实例容量。spot 实例更便宜，但可以在 AWS 上其他用户对实例有更高需求时被中断。SageMaker 管理的 spot 训练管理 spot 实例的使用，包括在 spot 实例再次可用时安全中断和及时恢复你的训练。

除了 spot 训练功能外，托管式检查点也是管理长时间运行任务的关键。在机器学习中，检查点是指在训练过程中保存的中间机器学习模型。数据科学家通常会创建检查点并跟踪每个时期内的最佳准确率。他们在进展过程中将准确率与最佳值进行比较，并使用具有最高准确率的检查点模型，而不是最后一个时期的模型。

如果数据科学家想要微调模型，他们也可以从任何特定的检查点恢复并继续训练。由于 SageMaker 使用容器在远程计算实例上训练模型，检查点被保存在容器中的本地目录中。SageMaker 会自动将检查点从本地存储桶上传到你的 S3 存储桶。你可以通过指定它们在 S3 中的位置轻松地在另一个训练作业中重用这些检查点。在 SageMaker 管理的 spot 训练的上下文中，你不需要担心在训练作业的中断和恢复时上传和下载检查点文件。SageMaker 会为我们处理这些。

让我们运行一个示例来看看事情是如何工作的。使用 Python 3 (TensorFlow 2.3 Python 3.7 CPU Optimized) 内核和 ml.t3.medium 实例打开 Getting-Started-with-Amazon-SageMaker-Studio/chapter09/03-spot_training_checkpointing.ipynb。在这个笔记本中，我们将重用我们在 第五章 中为 IMDB 评论数据集进行的 TensorFlow 模型训练，即 使用 SageMaker Studio IDE 构建和训练机器学习模型，并对代码进行一些修改以展示如何使用 SageMaker 启用检查点和托管式 spot 训练：

1. 运行前五个单元格以设置 SageMaker 会话，并准备数据集。如果你已经运行了第一个 chapter09/01-smdp_tensorflow_sentiment_analysis.ipynb 笔记本，数据集应该已经可用。

2. 在 %%writefile code/tensorflow_sentiment_with_checkpoint.py 这一行代码中，我们将对 TensorFlow/Keras 代码进行修改。首先，我们在 parse_args() 函数中添加了一个新的 --checkpoint_dir 参数，用于指定由 SageMaker 设置的默认 /opt/ml/checkpoints 位置。

3. 在 __name__ == '__main__' 中，我们将添加一个检查，以查看 checkpoint_dir 是否在容器中本地存在。如果存在，列出目录以查看是否存在任何现有的检查点文件：

   if not os.listdir(args.checkpoint_dir):
       model = get_model(args)
       initial_epoch_number = 0
   else:    
       model, initial_epoch_number = load_model_from_checkpoints(args.checkpoint_dir)
   

如果 checkpoint_dir 不包含有效的检查点文件，这意味着没有先前的训练作业和附加到容器中的检查点，并且 checkpoint_dir 是为新模型训练而新创建的。如果它包含文件，这意味着之前的检查点文件被插入到这个训练作业中，并且应该作为 load_model_from_checkpoints() 函数中训练的起点。

1. 实现 load_model_from_checkpoints() 函数以列出给定目录中所有以 .h5 结尾的检查点文件，因为这是 Keras 保存模型的方式。使用 re 库中的 regex 来过滤文件名中的 epoch 数。然后我们可以识别出最新的检查点来加载，并使用这样的模型继续训练。我们假设在正则表达式操作中，epoch 数的范围是 0 到 999。

2. 在模型加载后，无论是新模型还是从检查点加载，在 Keras 中实现一个 tf.keras.callbacks.ModelCheckpoint 回调，以便在每个 epoch 后将模型检查点保存到 args.checkpoint_dir。

3. 在设置 sagemaker.tensorflow.TensorFlow 估算器时，向估算器提供以下附加参数：

   1. use_spot_instances：一个布尔值，用于选择是否在训练中使用 SageMaker Spot 实例。

   2. max_wait：当 use_spot_instances 为 True 时是必需的参数。这是一个等待 Spot 训练作业的超时时间（以秒为单位）。在此超时后，作业将被停止。

   3. checkpoint_s3_uri：用于持久保存检查点文件的 S3 存储桶位置。如果你传递一个已经包含检查点模型的 S3 存储桶位置，并传递一个更高的 epoch 数，脚本将选择最新的检查点并继续训练。例如，通过提供 checkpoint_s3_uri，它包含来自之前 50 个 epoch 运行的检查点，以及一个 epochs 超参数为 60，我们的脚本将从第五十个检查点继续训练，再进行另外 10 个 epoch。

   4. max_run：允许训练的最大运行时间（以秒为单位）。在此超时后，作业将被停止。此值需要小于或等于 max_wait。

下面的代码片段将构建一个估算器，用于使用托管 Spot 实例和检查点来训练模型：

use_spot_instances = True
max_run = 3600
max_wait = 3600
checkpoint_suffix = str(uuid.uuid4())[:8]
checkpoint_s3_uri = f's3://{bucket}/{prefix}/checkpoint-{checkpoint_suffix}'
estimator = TensorFlow(use_spot_instances=use_spot_instances,
                       checkpoint_s3_uri=checkpoint_s3_uri,
                       max_run=max_run,
                       max_wait=max_wait,
                       ...)

1. 其余步骤保持不变。我们在调用 .fit() 开始训练作业之前，指定超参数、数据输入和实验配置。

2. 想知道使用即时实例能节省多少吗？从左侧边栏的实验和试验中，我们可以调出试验的 AWS 设置详情，如图图 9.9所示，仅通过使用托管即时训练实例就能看到70%的节省：

图 9.9 – 使用托管即时训练节省 70%，如试验详情所示

节省 70%是非常显著的。这对于需要昂贵的计算实例且具有长时间训练的大型模型训练用例特别有益。只需向估计器添加四个额外的参数以及在训练脚本中做一些更改，我们就能节省 70%。

摘要

在本章中，我们介绍了如何使用 SageMaker 分布式训练库来训练深度学习模型：数据并行和模型并行。我们运行了一个 TensorFlow 示例，展示了如何修改脚本以使用 SageMaker 的分布式数据并行库，使用八个 GPU 设备，而不是之前我们所学的一个。这使得我们能够增加批量大小并减少在整个数据集上迭代所需的迭代次数，从而提高模型训练的运行时间。然后我们展示了如何将 SageMaker 的分布式模型并行库适配到用 PyTorch 编写的模型训练中。这使得我们能够通过将大型模型分割到所有 GPU 设备上来训练一个更大的神经网络模型。我们还展示了如何使用 SageMaker Debugger 轻松监控训练作业中的计算资源利用率，并在 SageMaker Debugger 洞察仪表板中可视化指标。最后，我们解释了如何调整训练脚本以使用完全托管的即时训练和检查点来在 SageMaker 中训练模型时节省成本。

在下一章中，我们将转换方向，学习如何监控生产中的 ML 模型。在生产中，ML 模型对未见过的推理数据进行推理可能或可能不会产生预期的质量预测，这些预测是在部署之前进行的评估中得出的。在 ML 生命周期中设置监控策略以确保模型在令人满意的水平上运行是至关重要的。SageMaker Studio 具有帮助您轻松设置模型监控功能，以监控生产中的 ML 模型。我们将学习如何配置 SageMaker Model Monitor 以及如何将其作为我们 ML 生命周期的一部分来使用。

第十章：使用 SageMaker Model Monitor 监控生产中的机器学习模型

将模型投入生产进行推理并不是机器学习生命周期的结束。这只是重要话题的开始：我们如何确保模型按照设计以及在实际生活中按预期运行？使用 SageMaker Studio 监控模型在生产中的表现，尤其是在模型从未见过的数据上，变得容易起来。您将学习如何为在 SageMaker 中部署的模型设置模型监控，检测数据漂移和性能漂移，并在 SageMaker Studio 中可视化结果，以便您可以自动让系统检测您的机器学习模型的退化。

在本章中，我们将学习以下内容：

• 理解机器学习中的漂移

• 在 SageMaker Studio 中监控数据和模型性能的漂移

• 在 SageMaker Studio 中审查模型监控结果

技术要求

对于本章，您需要访问github.com/PacktPublishing/Getting-Started-with-Amazon-SageMaker-Studio/tree/main/chapter10中的代码。

理解机器学习中的漂移

在生产中，一个机器学习模型需要对其性能进行仔细和持续的监控。一旦模型经过训练和评估，并不能保证它在生产环境中的表现与测试环境中的表现相同。与软件应用不同，软件应用可以通过单元测试来测试所有可能的边缘情况，而监控和检测机器学习模型的问题则相对困难。这是因为机器学习模型使用概率、统计和模糊逻辑来推断每个输入数据点的结果，而测试，即模型评估，通常是在没有真正了解生产数据的情况下进行的。数据科学家在生产之前能做的最好的事情就是从与真实世界数据非常接近的样本中创建训练数据，并使用样本外策略评估模型，以便得到一个无偏的关于模型在未见数据上表现的想法。在生产中，模型对进入的数据是完全未知的；如何评估实时模型性能，以及如何对评估采取行动，是机器学习模型生产化的一个关键话题。

模型性能可以通过两种方法进行监控。一种更直接的方法是捕获未见数据的真实情况，并将预测与真实情况进行比较。第二种方法是，将推理数据的统计分布和特征与训练数据进行比较，作为判断模型是否按预期行为的一个代理。

第一种方法需要在预测事件发生后确定真实结果（基线），这样我们就可以直接计算数据科学家在模型评估期间使用的相同性能指标。然而，在某些用例中，真实结果（基线）可能落后于事件很长时间，甚至可能根本不可用。

第二种方法基于这样一个前提，即机器学习模型从训练数据中统计和概率性地学习，当提供来自不同统计分布的新数据集时，其行为会有所不同。当数据不是来自相同的统计分布时，模型会返回无意义的输出。这被称为协变量漂移。因此，检测数据中的协变量漂移可以更实时地估计模型的表现。

Amazon SageMaker 模型监控器是 SageMaker 中的一个功能，它通过设置数据捕获、计算基线统计信息和按计划监控流量到您的 SageMaker 端点的漂移，持续监控托管在 SageMaker 上的模型质量。SageMaker 模型监控器有四种类型的监控器：

• 模型质量监控器：通过计算预测的准确性和实际基线标签来监控模型的性能

• 数据质量监控器：通过将特征与基线训练数据的特征进行比较，监控推理数据的统计特征

• 模型可解释性监控器：与 SageMaker Clarify 集成，使用 Shapley 值在时间上计算特征归因

• 模型偏差监控器：与 SageMaker Clarify 集成，监控数据和模型预测的偏差

一旦为端点设置了模型监控，您就可以在 SageMaker Studio 中可视化随时间推移的漂移和任何数据问题。让我们按照本章中的 ML 用例学习如何在 SageMaker Studio 中设置 SageMaker 模型监控器。我们将重点关注模型质量和数据质量监控。

在 SageMaker Studio 中监控数据和性能漂移

在本章中，让我们考虑一个 ML 场景：我们训练一个 ML 模型并将其托管在端点上。我们还向端点创建了人工推理流量，每个数据点都注入了随机扰动。这是为了向数据引入噪声、缺失和漂移。然后我们继续使用 SageMaker 模型监控器创建数据质量监控器和模型质量监控器。我们使用一个简单的 ML 数据集，即 UCI 的鲍鱼数据集(archive.ics.uci.edu/ml/datasets/abalone)，进行此演示。使用此数据集，我们训练一个回归模型来预测环数，这与鲍鱼的年龄成比例。

训练和托管模型

我们将遵循以下步骤来设置模型监控之前所需的内容——获取数据、训练模型、托管它并创建流量：

1. 使用Python 3 (Data Science)内核和ml.t3.median实例打开Getting-Started-with-Amazon-SageMaker-Studio/chapter10/01-train_host_predict.ipynb笔记本。

2. 运行前三个单元格以设置库和 SageMaker 会话。

3. 从源读取数据并进行最小处理，即把分类变量Sex编码为整数，以便我们稍后可以使用XGBoost算法进行训练。此外，我们将目标列Rings的类型改为浮点数，以确保真实值和模型预测（回归）的值在模型监控中保持一致。

4. 将数据随机分为训练集（80%）、验证集（10%）和测试集（10%）。然后，将数据保存到本地驱动器以进行模型推理，并将其上传到 S3 进行模型训练。

5. 对于模型训练，我们使用 SageMaker 内置的XGBoost算法，对于回归问题使用reg:squarederror目标函数：

   image = image_uris.retrieve(region=region, 
                     framework='xgboost', version='1.3-1')
   xgb = sagemaker.estimator.Estimator(...)
   xgb.set_hyperparameters(objective='reg:squarederror', num_round=20)
   data_channels={'train': train_input, 'validation': val_input}
   xgb.fit(inputs=data_channels, ...)
   

训练大约需要 5 分钟。

1. 模型训练完成后，我们可以使用 SageMaker 端点通过xgb.deploy()托管模型，就像我们在第七章，“在云中托管 ML 模型：最佳实践”中学到的那样。然而，默认情况下，SageMaker 端点不会保存传入的推理数据副本。为了监控模型性能和数据漂移，我们需要指导端点持久化传入的推理数据。我们使用sagemaker.model_monitor.DataCaptureConfig设置端点后的数据捕获，用于监控目的：

   data_capture_config = DataCaptureConfig(enable_capture=True, 
              sampling_percentage=100,                                         
              destination_s3_uri=s3_capture_upload_path)
   

在destination_s3_uri中指定 S3 存储桶位置。sampling_percentage可以是100（%）或更低，具体取决于你预期的实际流量量。我们需要确保我们捕获足够大的样本量，以便稍后进行任何统计比较。如果模型推理流量稀疏，例如每小时 100 次推理，你可能希望使用 100%的样本进行模型监控。如果你有高频率的模型推理用例，你可能能够使用更小的百分比。

1. 我们可以使用data_capture_config将模型部署到端点：

   predictor = xgb.deploy(...,
                  data_capture_config=data_capture_config)
   

2. 一旦端点准备就绪，让我们在验证数据集上应用回归模型，以创建用于模型质量监控的基线数据集。基线数据集应包含 CSV 文件中的真实值和模型预测的两列。然后，我们将 CSV 上传到 S3 存储桶位置：

   pred=predictor.predict(df_val[columns_no_target].values)
   pred_f = [float(i) for i in pred[0]]
   df_val['Prediction']=pred_f
   model_quality_baseline_suffix = 'abalone/abalone_val_model_quality_baseline.csv'
   df_val[['Rings', 'Prediction']].to_csv(model_quality_baseline_suffix, index=False)
   model_quality_baseline_s3 = sagemaker.s3.S3Uploader.upload(
           local_path=model_quality_baseline_suffix,
           desired_s3_uri=desired_s3_uri,
           sagemaker_session=sess)
   

接下来，我们可以使用测试数据集在端点上做一些预测。

创建推理流量和真实值

为了模拟现实生活中的推理流量，我们从测试数据集中取样本并添加随机扰动，例如随机缩放和删除特征。我们可以预期这会模拟数据漂移并扭曲模型性能。然后，我们将扰动数据发送到端点进行预测，并将真实值保存到 S3 存储桶位置。请按照以下步骤在同一笔记本中操作：

1. 这里，我们有两个添加随机扰动的函数：add_randomness()和drop_randomly()。前者函数随机乘以每个特征值（除了Sex函数），并随机分配一个二进制值给Sex。后者函数随机删除一个特征，并用NaN（不是一个数字）填充它。

2. 我们还有一个generate_load_and_ground_truth()函数，用于从测试数据的每一行读取数据，应用扰动，调用端点进行预测，在字典gt_data中构建真实值，并将其作为 JSON 文件上传到 S3 存储桶。值得注意的是，为了确保我们建立推理数据和真实值之间的对应关系，我们将每一对关联到inference_id。这种关联将允许模型监控器合并推理和真实值以进行分析：

   def generate_load_and_ground_truth():
       gt_records=[]
       for i, row in df_test.iterrows():
           suffix = uuid.uuid1().hex
           inference_id = f'{i}-{suffix}'
   
           gt = row['Rings']
           data = row[columns_no_target].values
           new_data = drop_random(add_randomness(data))
           new_data = convert_nparray_to_string(new_data)
           out = predictor.predict(data = new_data, 
                          inference_id = inference_id)
           gt_data = {'groundTruthData': {
                               'data': str(gt), 
                               'encoding': 'CSV',
                           },
                      'eventMetadata': {
                               'eventId': inference_id,
                           },
                      'eventVersion': '0',
                      }
           gt_records.append(gt_data)
       upload_ground_truth(gt_records, ground_truth_upload_path, datetime.utcnow()) 
   

我们在generate_load_and_ground_truth_forever()函数中用while循环包装这个函数，这样我们就可以使用线程进程生成持久流量，直到笔记本关闭：

def generate_load_and_ground_truth_forever():
    while True:
        generate_load_and_ground_truth()
from threading import Thread
thread = Thread(target=generate_load_and_ground_truth_forever)
thread.start()

1. 最后，在我们设置第一个模型监控器之前，让我们看看如何捕获推理流量：

   capture_file = get_obj_body(capture_files[-1])
   print(json.dumps(json.loads(capture_file.split('\n')[-2]), indent=2))
   {
     "captureData": {
       "endpointInput": {
         "observedContentType": "text/csv",
         "mode": "INPUT",
         "data": "1.0,0.54,0.42,0.14,0.805,0.369,0.1725,0.21",
         "encoding": "CSV"
       },
       "endpointOutput": {
         "observedContentType": "text/csv; charset=utf-8",
         "mode": "OUTPUT",
         "data": "9.223058700561523",
         "encoding": "CSV"
       }
     },
     "eventMetadata": {
       "eventId": "a9d22bac-094a-4610-8dde-689c6aa8189b",
       "inferenceId": "846-01234f26730011ecbb8b139195a02686",
       "inferenceTime": "2022-01-11T17:00:39Z"
     },
     "eventVersion": "0"
   }
   

注意captureData.endpointInput.data函数通过predictor.predict()使用eventMetadata. inferenceId中的唯一推理 ID 来获取推理数据。模型端点的输出在captureData.endpointOutput.data中。

我们已经完成了所有准备工作。现在我们可以继续在 SageMaker Studio 中创建模型监控器。

创建数据质量监控器

数据质量监控器会将传入的推理数据的统计信息与基线数据集的统计信息进行比较。您可以通过 SageMaker Studio UI 或 SageMaker Python SDK 设置数据质量监控器。我将通过 Studio UI 演示简单的设置过程：

1. 在左侧侧边栏的端点注册表中找到您新托管的端点，如图图 10.1所示。双击条目以在主工作区域中打开它：

![图 10.1 – 打开端点详情页

![img/B17447_10_001.jpg]

图 10.1 – 打开端点详情页

1. 点击数据质量选项卡，然后创建监控计划，如图图 10.2所示：

![图 10.2 – 在端点详情页创建数据质量监控计划

![img/B17447_10_002.jpg]

图 10.2 – 在端点详情页创建数据质量监控计划

1. 在设置的第一个步骤中，如图图 10.3所示，我们选择一个 IAM 角色，该角色具有访问权限，可以读取和写入我们在以下页面指定的存储桶位置的结果。让我们选择3600秒（1 小时），这样监控作业就不会流入下一个小时。在页面底部，我们保持启用指标开启，这样模型监控器计算的指标也会发送到 Amazon CloudWatch。这允许我们在 CloudWatch 中可视化和分析指标。点击继续：

![图 10.3 – 数据质量监控器设置步骤 1

![img/B17447_10_003.jpg]

图 10.3 – 数据质量监控设置步骤 1

1. 在第二步中，如图图 10.4所示，我们配置了每小时监控作业的基础设施和输出位置。需要配置的基础设施是每小时将要创建的 SageMaker Processing 作业。我们将计算实例（实例类型、数量和磁盘卷大小）保留为默认设置。然后，我们提供一个监控结果的输出存储桶位置以及加密和网络（VPC）选项：

![图 10.4 – 数据质量监控设置步骤 2

![img/B17447_10_004.jpg]

图 10.4 – 数据质量监控设置步骤 2

1. 在第三步中，如图图 10.5所示，我们配置了基线计算。监控设置完成后，将启动一个一次性 SageMaker Processing 作业来计算基线统计数据。未来的周期性监控作业将使用基线统计数据来判断是否发生了漂移。我们将 CSV 文件位置提供到基线数据集的 S3 位置。我们将训练数据上传到 S3 存储桶，完整路径在train_data_s3变量中。我们提供一个 S3 输出位置到基线 S3 输出位置。因为我们的训练数据 CSV 文件的第一行包含一个特征名称，所以我们选择具有 1 GB 基线卷的ml.m5.xlarge实例就足够了。点击继续：

![图 10.5 – 数据质量监控设置步骤 3

![img/B17447_10_005.jpg]

图 10.5 – 数据质量监控设置步骤 3

1. 在最后的附加配置页面，您可以选择为周期性监控作业提供预处理和后处理脚本。您可以使用自己的脚本自定义特征和模型输出。当您使用自定义容器进行模型监控时，此扩展不受支持。在我们的案例中，我们使用 SageMaker 的内置容器。有关预处理和后处理脚本的更多信息，请访问docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-pre-and-post-processing.html。

如果您回到端点详情页面，在数据质量选项卡下，如图图 10.2所示，您现在可以看到一个新的具有已安排状态的监控计划。现在正在启动一个基线作业来从基线训练数据集中计算各种统计数据。基线作业完成后，第一个每小时监控作业将在小时顶部的 20 分钟内作为一个 SageMaker Processing 作业启动。监控作业计算在小时内收集的推理数据的统计数据，并将其与基线进行比较。我们将在在 SageMaker Studio 中查看模型监控结果部分中回顾监控结果。

现在，让我们继续创建模型质量监控器以监控模型性能。

创建模型质量监控器

创建模型质量监控器遵循与创建数据质量监控器类似的过程，但更注重处理 S3 中的模型预测和真实标签。让我们按照以下步骤设置一个模型质量监控器，以监控模型性能随时间的变化：

1. 在同一端点的端点详情页上，转到模型质量选项卡，并点击创建监控计划，如图图 10.6所示：

![图 10.6 – 在端点详情页创建模型质量监控计划

![img/B17447_10_006.jpg]

图 10.6 – 在端点详情页创建模型质量监控计划

1. 在第一页，计划，我们选择监控作业的 IAM 角色、调度频率等，类似于之前创建数据质量监控器部分中的步骤 3。

2. 在第二页，监控作业配置，如图图 10.7所示，我们配置监控作业的实例和输入/输出：

![图 10.7 – 设置模型质量监控器的输入和输出

![img/B17447_10_007.jpg]

图 10.7 – 设置模型质量监控器的输入和输出

输入既指模型从端点预测的结果，也指我们在笔记本中上传的真实标签文件。在24小时内。对于推理属性的0，指定第一个值是模型输出，并保留概率为空。

注意

如果您的模型内容类型是 JSON/JSON Lines，您会在{prediction: {"predicted_label":1, "probability":0.68}}中指定 JSON 路径，您会在"prediction.probability"中指定"prediction.predicted_label"，在概率中。

对于笔记本中的ground_truth_upload_path变量。对于S3 输出位置，我们指定一个 S3 存储桶位置，以便模型监控器保存输出。最后，您可以可选地配置监控作业的加密和 VPC。点击继续以进行下一步。

1. 在第三页，将笔记本中的model_quality_baseline_s3变量拖放到基线数据集 S3 位置字段。对于基线 S3 输出位置，我们提供一个 S3 位置以保存基线结果。在基线数据集格式中选择带标题的 CSV。将实例类型和配置保留为默认值。

这是为了配置 SageMaker Processing 作业进行一次性基线计算。在最后三个字段中，我们放入相应的 CSV 标题名称——Rings用于Prediction的基线推理属性——并将字段保留为空，因为我们的模型不产生概率。点击继续：

![图 10.8 – 配置模型质量监控器的基线计算

![img/B17447_10_008.jpg]

图 10.8 – 配置模型质量监控器的基线计算

1. 在附加配置中，我们可以向监控器提供预处理和后处理脚本，就像数据质量监控器的情况一样。让我们跳过这一部分，通过点击启用模型监控来完成设置。

现在，我们已经创建了模型质量监控器。您可以在ENDPOINT 详情页面的模型质量选项卡下看到监控计划处于已安排状态。类似于数据质量监控器，将启动一个基线处理作业来使用基线数据集计算基线模型性能。每小时监控作业也将作为一个 SageMaker Processing 作业在每小时顶部 20 分钟内启动，以便从每小时收集的推理数据中计算模型性能指标，并与基线进行比较。我们将在下一节中回顾监控结果，在 SageMaker Studio 中查看模型监控结果。

在 SageMaker Studio 中查看模型监控结果

SageMaker Model Monitor 对传入的推理数据进行各种统计计算，将它们与预先计算的基线统计进行比较，并将结果报告回指定的 S3 存储桶，您可以在 SageMaker Studio 中可视化这些结果。

对于数据质量监控器，SageMaker Model Monitor 预构建的默认容器，即我们所使用的，对基线数据集和推理数据进行每特征统计。这些统计包括平均值、总和、标准差、最小值和最大值。数据质量监控器还会检查数据缺失情况，并检查传入推理数据的数据类型。您可以在docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-interpreting-statistics.html找到完整的列表。

对于模型质量监控器，SageMaker 根据配置的 ML 问题类型计算模型性能指标。在本章的回归示例中，SageMaker 的模型质量监控器正在计算平均绝对误差（MAE）、平均平方误差（MSE）、均方根误差（RMSE）和R 平方（r2）值。您可以在docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality-metrics.html找到回归、二分类和多分类问题计算的完整指标列表。

您可以在ENDPOINT 详情页面的监控作业历史记录选项卡中查看随时间启动的监控作业列表，如图 10.9 所示：

![图 10.9 – 查看监控作业列表。双击行项目可进入特定作业的详细信息页]

![img/B17447_10_009.jpg]

图 10.9 – 查看监控作业列表。双击行项目可进入特定作业的详细信息页

当您双击行项目时，您将被带到特定监控作业的详细信息页面，如图图 10.10所示。由于我们在将数据发送到端点之前对其进行了扰动，因此数据包含不规则性，例如缺失。这被数据质量监控器捕获：

![图 10.10 – 数据质量监控作业的详细信息及违规情况

![img/B17447_10_010.jpg]

图 10.10 – 数据质量监控作业的详细信息及违规情况

我们还可以打开模型质量监控作业，以了解模型是否按预期运行。如图图 10.11所示，我们可以看到所有计算出的指标都提出了违规。我们知道这将会发生，因为这很大程度上是由于我们对数据引入的扰动。SageMaker 模型监控器能够检测到这样的问题：

![图 10.11 – 模型监控作业的详细信息及违规情况

![img/B17447_10_011.jpg]

图 10.11 – 模型监控作业的详细信息及违规情况

我们还可以从监控作业中创建可视化。让我们按照以下步骤创建数据质量监控器的图表：

1. 在端点详细信息页面，转到数据质量选项卡，然后点击如图图 10.12所示的添加图表按钮：

![图 10.12 – 为数据质量监控器添加可视化

![img/B17447_10_012.jpg]

图 10.12 – 为数据质量监控器添加可视化

1. 右侧将出现一个图表属性配置侧边栏，如图图 10.13所示。我们可以通过指定时间线、统计信息和我们要绘制的特征来创建图表。根据您启用监控器的时间长度，您可以选择一个时间范围进行可视化。例如，我选择了1 天的时间范围、平均统计信息和feature_baseline_drift_Length来查看过去一天中Length特征的平均基线漂移度量：

![图 10.13 – 在 SageMaker Studio 中可视化特征漂移

![img/B17447_10_013.jpg]

图 10.13 – 在 SageMaker Studio 中可视化特征漂移

1. 您可以通过点击添加图表按钮来可选地添加更多图表。

2. 同样，我们可以使用过去 24 小时的mse指标来可视化模型性能，如图图 10.14所示：

![图 10.14 – 在 SageMaker Studio 中可视化 mse 回归指标

![img/B17447_10_014.jpg]

图 10.14 – 在 SageMaker Studio 中可视化 mse 回归指标

注意

为了节省成本，当您完成示例后，请确保取消注释并运行01-train_host_predict.ipynb中的最后几个单元格，以删除监控计划和端点，从而停止向您的 AWS 账户收费。

摘要

在本章中，我们专注于机器学习中的数据漂移和模型漂移，以及如何使用 SageMaker 模型监控器和 SageMaker Studio 来监控它们。我们演示了如何在 SageMaker Studio 中设置数据质量监控器和模型质量监控器，以持续监控模型的行为和输入数据的特征，在一个回归模型部署在 SageMaker 端点并且持续推理流量击中端点的情况下。我们引入了一些随机扰动到推理流量中，并使用 SageMaker 模型监控器来检测模型和数据的不当行为。通过这个例子，你还可以将 SageMaker 模型监控器部署到你的用例中，为你的生产模型提供可见性和保障。

在下一章中，我们将学习如何使用 SageMaker Projects、Pipelines 和模型注册表来操作化一个机器学习项目。我们将讨论当前机器学习中的一个重要趋势，即持续集成/持续交付（CI/CD）和机器学习运营（MLOps）。我们将演示如何使用 SageMaker 的功能，如 Projects、Pipelines 和模型注册表，使你的机器学习项目可重复、可靠和可重用，并具有强大的治理能力。

第十一章：使用 SageMaker 项目、管道和模型注册实现机器学习项目的运营化

数据科学家过去花费太多时间和精力维护和手动管理机器学习管道，这个过程从数据、处理、训练和评估开始，以模型托管和持续维护结束。SageMaker Studio 提供了旨在通过持续集成和持续交付（CI/CD）最佳实践简化这些操作的功能。您将学习如何实现 SageMaker 项目、管道和模型注册，以帮助通过 CI/CD 实现机器学习生命周期的运营化。

在本章中，我们将学习以下内容：

• 理解机器学习操作和 CI/CD

• 创建 SageMaker 项目

• 使用 SageMaker 管道编排机器学习管道

• 在 SageMaker Studio 中运行 CI/CD

技术要求

对于本章，您需要确保在工作室设置中启用了 SageMaker 项目模板权限。如果您已经完成了第八章，使用 SageMaker JumpStart 和 Autopilot 快速启动机器学习，您应该拥有这些权限。您可以在工作室域名视图中通过以下步骤进行验证：

1. 如果如图 11.1所示，任一权限被禁用，您可以点击编辑设置来更改此设置。

![图 11.1 – 检查和编辑 SageMaker 项目权限

]

图 11.1 – 检查和编辑 SageMaker 项目权限

1. 前往步骤 2 工作室设置，如图图 11.2所示，切换 SageMaker 项目和 JumpStart 权限。

![图 11.2 – 为账户和用户启用 SageMaker 项目模板

]

图 11.2 – 为账户和用户启用 SageMaker 项目模板

1. 然后点击下一步进入下一页，并点击提交。

这确保了 SageMaker 项目模板权限为您启用。

理解机器学习操作和 CI/CD

在机器学习生命周期中，有许多步骤需要数据科学家全程动手操作，例如处理数据集、训练和评估模型。这些手动步骤可能会影响机器学习团队的运营和将模型部署到生产中的速度。想象一下，您的模型训练作业耗时很长，并在半夜完成。您要么必须等到白天第一个数据科学家到来评估模型并将模型部署到生产中，要么必须安排值班轮换，让有人在任何时候都待命以监控模型训练和部署。但这两个选项都不理想，如果您希望有一个有效且高效的机器学习生命周期。

机器学习运维（MLOps）对于想要保持精简并良好扩展的团队至关重要。MLOps 帮助你尽可能简化并减少人工干预。它帮助你将 ML 生命周期转变为企业级。它帮助你扩展并维护投入生产中的模型的质量，同时也有助于通过自动化提高模型交付的时间。

那么，MLOps 究竟是什么呢？

MLOps 指的是一种将 DevOps 最佳实践应用于机器学习生命周期的方法论。DevOps代表软件开发（Dev）和 IT运维（Ops）。DevOps 旨在通过一套工程、实践和模式，提高团队快速、高质量交付应用程序的能力。它还促进了一个组织中的新文化和行为范式。MLOps 推荐以下实践，这些实践基于 DevOps 最佳实践，并针对 ML 的特性进行了一些修改：

• 持续集成（CI）：在 DevOps 中，开发者不断提交并合并他们的代码更改到中央仓库，之后自动运行测试以验证代码。在机器学习（ML）中，不仅代码需要集成和验证，训练数据和 ML 模型也是如此。训练数据需要版本控制，模型血缘需要追踪以实现可追溯性，除了代码之外，数据和模型的测试也需要实施。

• 持续交付（CD）：在 DevOps 中，这是一种自动构建、测试和发布生产代码的实践。在 MLOps 中，与持续集成讨论的内容类似，操作包括除了 ML 源代码之外的数据和模型。

• 一切皆代码：为了使持续集成和持续部署（CI/CD，简称 CI/CD）流程简化和自动化，一切都需要以代码的形式实现：流程、基础设施和配置，而不是在屏幕上任何手动设置和点击操作。这种做法也使得你的流程、基础设施和配置能够实现版本控制和可重复性。

• 监控和日志记录：这种实践鼓励你记录与你的软件/ML 系统相关的所有内容，以实现可见性和可审计性。你不仅记录 ML 指标、数据血缘、数据版本和模型版本，还记录 CI/CD 流程以及任何错误，用于调试和监控目的。这为下一个实践提供了支持。

• 沟通与协作：因为一切皆代码，一切皆自动化并记录，你拥有一个透明的工作环境，这鼓励协作和沟通。而不是在孤岛中手动交接，这会导致摩擦和透明度降低，你的整个团队能够更紧密地在系统上协作工作。

MLOps 带来的关键益处如下：

• 更快的上市时间：因为现在你的模型部署是作为 CI/CD 流程的一部分自动创建和部署的，所以你的模型训练和部署流程得到了简化，没有任何交接或手动流程。你可以在相同的时间内期待更多的迭代优化，并且成熟产品的周转时间会更快。

• 生产力：许多手动流程从数据科学家和 ML 开发人员那里移除，使他们能够专注于无法自动化的 ML 模型构建。

• 可重复性：此外，由于一切都是代码并且是自动化的，你的 ML 生命周期可以由任何人在任何时候以完全相同的结果执行。

• 可靠性：在 CI/CD 流程中进行的测试和验证，让你知道你的模型质量很高。由于 CI/CD 提供的可重复性，你还可以持续地生产高质量的模型。

• 可审计性：由于代码、数据和模型都有版本控制，并且记录了血缘和流程，你可以确切地知道模型是如何被训练和部署的。

• 更好的质量：结合上述所有优点，MLOps 使我们能够花更多的时间创建更好的模型，并让系统快速、可靠、可重复地处理集成和交付。

你可能会想：MLOps 看起来太完美了，难以轻易采用。是的，你确实需要在你的 ML 生命周期中整合额外的技术来启用 CI/CD 流程。是的，你需要实施许多细节来启用日志记录和监控。同样，为了采用“一切皆代码”的实践，在开始时确实需要对基础设施代码和配置进行许多迭代测试。好消息是，在 SageMaker Studio 中，为你的 ML 项目采用 MLOps 实践变得很容易。SageMaker Studio 为许多用例模板化了 CI/CD 流程，这样你就可以轻松选择一个，并从模板化的 ML 用例中采用 MLOps 最佳实践和技术，以适应你的用例。使 MLOps 和 CI/CD 成为可能的特性包括 SageMaker 项目、SageMaker 流程和SageMaker 模型注册。

首先，让我们通过创建一个 SageMaker 项目来开始。

创建一个 SageMaker 项目

SageMaker 项目使你能够通过 SageMaker 提供的模板和自己的自定义模板，使用 MLOps 和 CI/CD 自动化模型构建和部署流程。使用 SageMaker 提供的模板，所有初始设置和资源分配都由 SageMaker 处理，因此你可以快速将其应用于你的用例。

在本章中，我们将使用 SageMaker Studio 中的 MLOps 和 CI/CD 运行一个 ML 示例。由于本章我们专注于 MLOps 和 CI/CD，我们使用来自鲍鱼数据集（archive.ics.uci.edu/ml/datasets/abalone）的简单回归问题来预测鲍鱼的年龄。我将向您展示如何从 SageMaker 项目创建项目，以及 MLOps 系统的每个部分是如何工作的。从 SageMaker 项目创建的 MLOps 系统可以通过简单的代码提交触发器自动化数据验证、模型构建、模型评估、部署和监控。这意味着每当我们对代码库进行任何更改时，整个系统将自动运行我们在这本书中学到的 SageMaker 的完整 ML 生命周期。您将看到 SageMaker 为您简化了多少 MLOps。让我们打开 SageMaker Studio 并遵循这里给出的步骤：

1. 在启动器页面，点击新建项目卡片上的加号，如图图 11.3所示。

![Figure 11.3 – Opening a new project in Launcher

图 11.3 – 在启动器中打开新项目

1. SageMaker（在SageMaker 模板下）为我们创建了各种用例的 MLOps 模板，如图图 11.4所示。让我们选择用于模型构建、训练、部署和监控的 MLOps 模板。此模板自动化整个模型生命周期，包括模型构建、部署和监控工作流程。点击选择项目模板。

![Figure 11.4 – Choosing SageMaker managed templates

图 11.4 – 选择 SageMaker 托管模板

注意

模板名称包含与第三方 Git 仓库的模板旨在与您的外部 Git 仓库或 CI/CD 软件（如Jenkins）一起使用。您需要在下一步提供更多信息。

1. 在项目详情页面为项目提供名称、描述和标签。点击创建项目。

使用此项目模板，SageMaker Studio 现在正在为 MLOps 配置云资源并部署示例代码。让我们用图图 11.5所示的图表来展示 MLOps 架构：

![Figure 11.5 – Architecture diagram of an MLOps setup with a SageMaker projects template

图 11.5 – 使用 SageMaker 项目模板的 MLOps 设置架构图

创建的云资源包括以下内容：

• 在AWS CodeCommit中有三个代码仓库，这是一个托管私有 Git 仓库的托管源代码管理服务。它们也可以在 AWS CodeCommit 控制台中找到：console.aws.amazon.com/codesuite/codecommit/repositories。请记住从 URL 切换到您自己的 AWS 区域。

• 在AWS CodePipeline中，一个帮助自动化构建、测试和发布管道的托管服务，有三个持续交付管道可以在 AWS CodePipeline 控制台中找到：console.aws.amazon.com/codesuite/codepipeline/pipelines。请记住从 URL 切换到您自己的 AWS 区域。

• 在Amazon EventBridge中，一个使构建事件驱动应用程序更容易的托管服务，可以在 Amazon EventBridge 控制台中找到五个事件触发规则：console.aws.amazon.com/events/home#/rules。请记住从 URL 切换到您自己的 AWS 区域。

这些基本上是支持 SageMaker Studio 中 MLOps 的 CI/CD 框架的骨干。CodeCommit 中的仓库是我们存储、开发和提交代码的地方。对 CodeCommit 中代码仓库的每次提交都将触发，由 EventBridge 中的规则管理，在 CodePipeline 中运行相应的管道以构建、测试和部署资源。

一旦项目创建完成，您可以在主工作区域中看到项目门户，如图 11.6 所示。

图 11.6 – SageMaker 项目详情门户

此门户包含与项目相关联的所有重要资源和信息——CodeCommit 中的代码仓库、SageMaker Pipelines 中的 ML 管道（我们很快会讨论到），使用 SageMaker Experiments 跟踪的实验、模型、托管端点和其他设置。

1. 我们可以从 CodeCommit 克隆仓库到本地 SageMaker Studio 目录。在我们开始描述 ML 管道之前，作为最后一步，让我们克隆<项目名称前缀>-modelbuild仓库，该仓库包含使用鲍鱼数据集构建、训练和评估 ML 模型的 ML 管道。点击如图 11.6 中用箭头突出显示的<项目名称前缀>-modelbuild仓库。

图 11.7 – 从 CodeCommit 克隆仓库到本地 SageMaker Studio 目录

1. 在如图 11.7 所示的弹出窗口中，点击~/<项目名称前缀>/<项目名称前缀>-modelbuild/。

在我们深入 CI/CD 部分之前，让我们首先看看这个鲍鱼示例中定义的 ML 管道。

使用 SageMaker Pipelines 编排 ML 管道

我们使用的模板包含一个机器学习生命周期管道，该管道执行数据预处理、数据质量检查、模型训练、模型评估步骤，最终进行模型注册。该管道是 MLOps 流程中的核心部分，其中正在创建模型。该管道使用 SageMaker Pipelines 定义在<project-name-prefix>-modelbuild中。SageMaker Pipelines是 SageMaker 中机器学习工作流程的编排工具。SageMaker Pipelines 与 SageMaker Processing、训练、实验、托管和模型注册集成。它提供了可重复性、可重复性和审计的可追溯性。最重要的是，您可以在 SageMaker Studio 中可视化工作流程图和实时运行状态。该管道可以在详情门户的管道选项卡下找到，如图 11.8 所示。

图 11.8 – 项目中的管道列表

注意

在本章中，我多次使用了管道这个术语。让我们一次性解决这个问题。我指的是图 11.8 和图 11.9 中显示的 SageMaker Pipelines 的管道，即ML 管道。请勿将 ML 管道与 AWS CodePipeline 的 CI/CD 管道混淆，后者在上一个部分中简要提及，将在在 SageMaker Studio 中运行 CI/CD部分中进一步讨论。

双击管道后，我们可以看到完整的执行图和管道的实时状态，如图 11.9 所示。相应的管道代码位于~/<project-name-prefix>/<project-name-prefix>-modelbuild/pipelines/abalone/pipeline.py。

图 11.9 – 管道工作流程和实时状态

让我们遍历管道以及它在代码中的设置。管道包含以下步骤（从图中自上而下）：

1. 首先，使用 SageMaker Processing（pipeline.py文件，我们在sagemaker.workflow模块中使用类和函数，以及其他sagemaker类，定义了一个 scikit-learn 处理器来运行同一目录下的preprocess.py脚本。此外，ProcessingStep是sagemaker.workflow.steps模块中的一个类：

   # Line 209 in pipeline.py
   step_process = ProcessingStep(
       name="PreprocessAbaloneData",
       processor=sklearn_processor,
       outputs=[
           ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
           ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
           ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
       ],
       code=os.path.join(BASE_DIR, "preprocess.py"),
       job_arguments=["--input-data", input_data],
   )
   

2. 数据预处理完成后，管道将检查之前注册的数据质量偏差指标，并/或使用 SageMaker Clarify 计算数据质量和偏差。在这里，前一步骤step_process.properties.ProcessingOutputConfig.Outputs["train"]的输出被用作输入基线数据。在这里实例化了一个QualityCheckStep()步骤对象。此步骤从基线训练数据中计算数据质量统计信息，并在模型创建结束时将统计信息注册到模型注册表中：

   # Line 238
   data_quality_check_config = DataQualityCheckConfig(
   baseline_dataset=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
       dataset_format=DatasetFormat.csv(header=False, output_columns_position="START"),
       output_s3_uri=Join(on='/', values=['s3:/', default_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'dataqualitycheckstep'])
   )
   data_quality_check_step = QualityCheckStep(
       name="DataQualityCheckStep",
       skip_check=skip_check_data_quality,
       register_new_baseline=register_new_baseline_data_quality,
       quality_check_config=data_quality_check_config,
       check_job_config=check_job_config,
   supplied_baseline_statistics=supplied_baseline_statistics_data_quality,
   supplied_baseline_constraints=supplied_baseline_constraints_data_quality,
       model_package_group_name=model_package_group_name
   )
   

3. 同时，该管道还使用从ClarifyCheckStep()类实例化的步骤来计算数据偏差：

   data_bias_check_config = DataBiasCheckConfig(
       data_config=data_bias_data_config,
       data_bias_config=data_bias_config,
   )
   data_bias_check_step = ClarifyCheckStep(
       name="DataBiasCheckStep",
       clarify_check_config=data_bias_check_config,
       check_job_config=check_job_config,
       skip_check=skip_check_data_bias,
       register_new_baseline=register_new_baseline_data_bias,
       model_package_group_name=model_package_group_name
   )
   

这两个检查步骤基于 skip_check 参数是条件性的。skip_check_data_quality 和 skip_check_data_bias 是管道输入参数，并且可以为每次运行进行配置。对于第一次运行，你可能可以跳过检查，因为没有基线统计数据可供比较。register_new_baseline 也是从管道输入参数中条件性的，但大多数情况下，当你有一个新的数据集时，你会注册新的基线统计数据，除非你有不更新统计数据的特定原因。

1. 在数据质量和偏差检查之后，从 SageMaker 估算器创建一个训练作业。在这个例子中，使用了内置的 XGBoost 算法。TrainingStep 依赖于 DataQualityCheckStep 和 DataBiasCheckStep，这意味着训练步骤在开始之前等待两个检查步骤完成，并从预处理步骤的输出 step_process 中获取：

   # Line 326
   step_train = TrainingStep(
       name="TrainAbaloneModel",
       depends_on=["DataQualityCheckStep", "DataBiasCheckStep"],
       estimator=xgb_train,
       inputs={
           "train": TrainingInput(
   s3_data=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
               content_type="text/csv",
           ),
           "validation": TrainingInput(
   s3_data=step_process.properties.ProcessingOutputConfig.Outputs["validation"].S3Output.S3Uri,
               content_type="text/csv",
           ),
       },
   )
   

2. 接下来是使用 CreateModelStep() 从训练作业创建 SageMaker 模型。CreateModelInput() 接收用于托管目的的实例类型：

   # Line 346
   model = Model(
       image_uri=image_uri,
   model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
       sagemaker_session=sagemaker_session,
       role=role,
   )
   inputs = CreateModelInput(
       instance_type="ml.m5.large",
       accelerator_type="ml.eia1.medium",
   )
   step_create_model = CreateModelStep(
       name="AbaloneCreateModel",
       model=model,
       inputs=inputs,
   )
   

3. 一旦创建了 SageMaker 模型，就会执行两个模型评估分支。一个是使用 SageMaker 批量转换 Transformer 在保留的测试集上进行的评估：

   # Line 364
   transformer = Transformer(
       model_name=step_create_model.properties.ModelName,
       instance_type="ml.m5.xlarge",
       instance_count=1,
       accept="text/csv",
       assemble_with="Line",
       output_path=f"s3://{default_bucket}/AbaloneTransform",
   )
   step_transform = TransformStep(
       name="AbaloneTransform",
       transformer=transformer,
       inputs=TransformInput(       data=step_process.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
       ...)
   )
   

   注意

   在这里文本中省略的 TransformInput() 类的附加参数，但在 pipeline.py 中可用，是为了配置批量转换的输入/输出，并将输出结果与输入记录关联。更多信息，请参阅 docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html。

批量转换的输出，即预测，然后用于计算模型质量指标，如平均绝对误差、均方根误差和 r 平方值：

model_quality_check_config = ModelQualityCheckConfig(
    baseline_dataset=step_transform.properties.TransformOutput.S3OutputPath,
    dataset_format=DatasetFormat.csv(header=False),
    output_s3_uri=Join(on='/', values=['s3:/', default_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'modelqualitycheckstep']),
    problem_type='Regression',
    inference_attribute='_c0',
    ground_truth_attribute='_c1'
)
model_quality_check_step = QualityCheckStep(
    name="ModelQualityCheckStep",
    skip_check=skip_check_model_quality,
    register_new_baseline=register_new_baseline_model_quality,
    quality_check_config=model_quality_check_config,
    check_job_config=check_job_config,
supplied_baseline_statistics=supplied_baseline_statistics_model_quality,
supplied_baseline_constraints=supplied_baseline_constraints_model_quality,
    model_package_group_name=model_package_group_name
)

1. 另一个评估路线 EvaluateAbaloneModel 和 CheckMSEAbaloneEvalution 的目的是评估测试数据集，并将性能指标作为 ML 管道中的条件，只有当均方误差小于或等于 6.0 时才继续注册模型到模型注册表中：

   # Line 650
   cond_lte = ConditionLessThanOrEqualTo(
       left=JsonGet(
           step=step_eval,
           property_file=evaluation_report,
           json_path="regression_metrics.mse.value"
       ),
       right=6.0,
   )
   step_cond = ConditionStep(
       name="CheckMSEAbaloneEvaluation",
       conditions=[cond_lte],
       if_steps=[step_register],
       else_steps=[],
   )
   

2. 在 ModelBiasCheckStep 和 ModelExplainabilityCheckStep 中也对模型应用了其他检查。它们都使用 SageMaker Clarify 来计算模型偏差和模型可解释性：

   # Line 450
   model_bias_check_step = ClarifyCheckStep(
       name="ModelBiasCheckStep",
       clarify_check_config=model_bias_check_config,
       check_job_config=check_job_config,
       skip_check=skip_check_model_bias,
       register_new_baseline=register_new_baseline_model_bias,
   supplied_baseline_constraints=supplied_baseline_constraints_model_bias,
       model_package_group_name=model_package_group_name
   ) 
   # Line 494
   model_explainability_check_step = ClarifyCheckStep(
       name="ModelExplainabilityCheckStep",
       clarify_check_config=model_explainability_check_config,
       check_job_config=check_job_config,
       skip_check=skip_check_model_explainability,
   register_new_baseline=register_new_baseline_model_explainability,
   supplied_baseline_constraints=supplied_baseline_constraints_model_explainability,
       model_package_group_name=model_package_group_name
   )
   

3. 在确认模型性能的检查之后，模型连同评估指标一起注册到 SageMaker 模型注册表中，这些指标存储在 model_metrics 变量中，并在过程中捕获，包括测试数据上的性能指标、数据偏差和模型偏差：

   # Line 635
   step_register = RegisterModel(
       name="RegisterAbaloneModel",
       estimator=xgb_train,
   model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
       content_types=["text/csv"],
       response_types=["text/csv"],
       inference_instances=["ml.t2.medium", "ml.m5.large"],
       transform_instances=["ml.m5.large"],
       model_package_group_name=model_package_group_name,
       approval_status=model_approval_status,
       model_metrics=model_metrics,
       drift_check_baselines=drift_check_baselines
   )
   

4. 定义步骤后，它们被放入 Pipeline 对象的 steps 参数中。暴露给用户的参数放在 parameters 参数中：

   # Line 666
   pipeline = Pipeline(
       name=pipeline_name,
       parameters=[
           processing_instance_type,
           processing_instance_count,
           ...],
       steps=[step_process, data_quality_check_step, data_bias_check_step, step_train, step_create_model, step_transform, model_quality_check_step, model_bias_check_step, model_explainability_check_step, step_eval, step_cond],
       sagemaker_session=sagemaker_session,
   )
   

您可能会想知道 SageMaker 如何确定步骤的顺序。SageMaker 根据数据依赖关系和任何显式或自定义依赖关系来确定顺序。我们将步骤放入 steps 参数的列表中，SageMaker 会处理其余部分。

注意

项目创建后，三个 CodePipeline 管道将自动运行。只有第一个管道 <project-name-prefix>-modelbuild 将正确执行。其他两个管道 <project-name-prefix>-modeldeploy 和 <project-name-prefix>-modelmonitor 依赖于第一个管道的输出，因此它们在第一次运行中将会失败。现在不用担心失败状态。

1. 最后，成功执行的管道将在 SageMaker 模型注册表中创建和注册一个模型。您可以在左侧侧边栏中看到该模型，如图 图 11.10 所示。我们将在后面的章节中了解更多关于模型注册表的信息。

图 11.10 – 在 SageMaker 模型注册表中生成的模型

运行管道有多种方式。一种是通过 CI/CD 流程，这是从模板部署后管道最初运行的方式。我们将在下一节 在 SageMaker Studio 中运行 CI/CD 中更多地讨论 CI/CD 流程。以下是如何手动触发管道的示例：

1. 您可以从 SageMaker Studio UI 中点击 启动执行，如图 图 11.11 所示。

图 11.11 – 在管道列表中启动管道执行

1. 您可以指定用户输入，例如实例类型、训练数据位置和其他检查条件，如图 图 11.12 所示。点击 启动 以单独为新的数据集启动工作流程。

图 11.12 – 使用用户输入启动管道执行

1. 您还可以使用 SageMaker Python SDK 运行管道。模板化的代码存储库 ~/<project-name-prefix>/<project-name-prefix>-modelbuild/ 中有一个示例笔记本 sagemaker-pipelines-project.ipynb，它更详细地解释了代码结构，并展示了如何程序化运行管道。您可以根据 图 11.13 中的说明打开笔记本，并作为替代方案运行它。

图 11.13 – 显示存储库中代码结构等详细信息的 sagemaker-pipelines-project.ipynb 笔记本截图，并程序化运行管道

使用 SageMaker 管道，我们可以编排使用 SageMaker 托管功能运行的机器学习（ML）生命周期中的步骤。在下一节中，我们将看到模板创建的 CI/CD 系统是如何使用 SageMaker 管道进行 MLOps 的。

在 SageMaker Studio 中运行 CI/CD

我们之前看到的机器学习（ML）管道只是我们 CI/CD 系统中正在运行的一部分。机器学习（ML）管道是由 AWS CodePipeline 中的 CI/CD 管道触发的。让我们深入了解 SageMaker 项目模板为我们设置的三个 CI/CD 管道。

有三个 CodePipeline 管道：

• <project-name-prefix>-modelbuild：这个管道的目的是运行机器学习（ML）管道并在 SageMaker 模型注册表中创建一个机器学习模型。当仓库中提交触发时，这个 CI/CD 管道将机器学习（ML）管道作为构建步骤运行。SageMaker 模型注册表中的机器学习（ML）模型需要获得批准才能触发下一个管道modeldeploy。

• <project-name-prefix>-modeldeploy：这个管道的目的是将 SageMaker 模型注册表中最新的批准的机器学习（ML）模型部署为一个 SageMaker 端点。构建过程首先部署一个预发布端点，并在将模型部署到生产之前请求手动批准。这确保了在部署到生产之前模型和端点配置是正常工作的。一旦预发布端点部署并处于InService状态，它将触发下一个管道modelmonitor。

• <project-name-prefix>-modelmonitor：这个管道的目的是将 SageMaker 模型监控器部署到modeldeploy管道中创建的两个 SageMaker 端点。每当预发布端点上线时，这个管道都会触发，并在将模型监控器部署到生产端点之前对预发布端点的模型监控部署进行手动批准。

回到我们之前提到的机器学习（ML）管道执行过程，这是modelbuild构建过程的一部分，我们已经创建并注册了一个模型到模型注册表中。这是 CI/CD 系统的第一个检查点：手动验证模型性能指标。为了继续进行，我们需要像图 11.10所示的那样访问模型注册表来审查结果。

1. 从图 11.10的视图中，双击模型版本条目在模型注册表中查看关于这个模型版本的更多详细信息，如图图 11.14所示。

图 11.14 – 模型版本详情页

1. 我们可以在模型质量标签页中查看模型性能，在可解释性标签页中查看模型可解释性，以及在偏差报告标签页中查看数据偏差。这些都是帮助我们决定这个模型是否可接受的相关信息。

2. 点击右上角的 更新状态 按钮在审查后批准或拒绝此模型。为了演示目的，我们批准模型以继续 MLOps 系统，如图 图 11.15 所示。如果我们拒绝模型，从这一点开始将不会发生任何事情。

图 11.15 – 批准或拒绝模型版本。你还可以在框中添加注释

1. 模型批准会自动触发 modeldeploy 管道的执行。如果你进入 CodePipeline 控制台，你可以看到它处于 进行中 状态，如图 图 11.16 所示。

图 11.16 – 模型批准自动触发 modeldeploy 管道

1. 如前所述，modeldeploy 管道首先部署一个用于审查的预发布 SageMaker 端点。一旦端点创建完成（5-7 分钟），你可以在模型版本页面上看到一个新事件，如图 图 11.17 所示。点击 Endpoint: -staging 以获取有关端点的更多信息。你可以测试端点。

图 11.17 – 显示预发布端点部署最新事件的模型版本

1. 确认端点状态后，我们可以在 CodePipeline 控制台中批准预发布端点部署。点击 图 11.16 中的管道名称。我们可以看到管道当前进度在 DeployStaging 阶段处于待定状态，如图 图 11.18 所示。在 ApproveDeployment 步骤中点击 Review 按钮以批准/拒绝部署。

图 11.18 – modeldeploy 管道需要手动批准

1. 在弹出窗口中批准或拒绝部署，并添加任何注释，如图 图 11.19 所示。由于端点是实时且正在工作的，让我们批准预发布部署。

图 11.19 – 批准/拒绝预发布部署

1. modeldeploy 管道继续进入最终阶段，DeployProd，将模型部署到生产端点。一旦部署完成，管道状态更新为 成功。你可以在模型版本页面上看到一个新事件，如图 图 11.20 所示。同时注意 最后阶段 现在是 prod。

图 11.20 – 模型版本现在更新到 prod

1. 当我们批准预发布部署时，modelmonitor 管道被触发以将 SageMaker Model Monitor 部署到预发布端点。我们可以在 CodePipeline 控制台中看到 modelmonitor 管道处于 进行中 状态，如图 图 11.21 所示。

图 11.21 – 阶段端点部署触发模型监控器管道

1. modelmonitor管道在 DeployStaging 阶段也需要手动批准。我们应该检查端点以查看是否启用了模型监控器。如图图 11.22所示，我们可以在数据质量选项卡中看到模型监控器确实已启用并已安排。我们尚未为端点设置实时流量，监控计划将在每小时开始时启动，因此让我们在 CodePipeline 控制台中继续并批准 DeployStaging，类似于步骤 6和步骤 7。

图 11.22 – 检查模型监控器阶段端点的计划

1. 最后，DeployProd 阶段还将 SageMaker Model Monitor 部署到生产端点。这标志着完整的 MLOps 和 CI/CD 系统的结束。

CodePipeline 中的三个 CI/CD 管道构成了一个通用的 MLOps 系统，该系统可以响应对modelbuild仓库的任何代码更改以及任何手动 ML 管道运行，实现 ML 模型的持续集成和持续交付。您不必担心复杂的实现，因为这些步骤都是自动进行的，多亏了 SageMaker 项目模板。

SageMaker Projects 通过模板化的代码和仓库，使您能够轻松地将强大的 MLOps 系统带入自己的 ML 用例。您不必构建复杂的系统。您只需选择 SageMaker 项目提供的适合您用例的模板，并遵循 CodeCommit 中仓库中的 README 文件来自定义配置和代码以适应您的用例。例如，我们可以更新pipeline.py中的模型训练以使用不同的超参数集，如下面的代码块所示，并将更改提交到modelbuild仓库：

# Line 315 in pipeline.py
xgb_train.set_hyperparameters(
    objective="reg:linear",
    num_round=70, # was 50
    max_depth=7, # was 7
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7,
    silent=0)

您可以从modelbuild管道中看到最新的提交消息，从而看到一个新的执行情况，如图图 11.23所示。

图 11.23 – 通过对仓库的提交触发新的模型构建执行

CI/CD 管道将再次按照本章所述运行，以便在更新核心训练算法版本后自动交付新的模型/端点（除了手动批准步骤）。您可以将此应用于 ML 管道的任何更改、modelbuild管道中的配置或其他两个 CI/CD 管道中的配置。

摘要

在本章中，我们描述了 MLOps 是什么以及它在 ML 生命周期中扮演的角色。我们讨论了 MLOps 带来的好处。我们展示了如何通过 SageMaker Studio IDE 中的 SageMaker 项目轻松启动一个复杂的 MLOps 系统。我们从 SageMaker 项目中部署了一个模型构建/部署/监控模板，并体验了“一切皆代码”的真正含义。

我们对 CI/CD 流程进行了全面运行，以了解这个 MLOps 系统中的工作原理。我们详细学习了如何使用 SageMaker Pipelines 和其他 SageMaker 管理功能实现 ML 流程。我们还学习了 SageMaker 模型注册如何用于版本控制 ML 模型。

此外，我们还展示了如何监控 CI/CD 流程并在 CodePipeline 中批准部署，这为你提供了对模型和部署质量的严格控制。有了 MLOps 系统，你可以享受到我们讨论的好处：更快的上市时间、生产力、可重复性、可靠性、可审计性和高质量的模型。

这个例子也完美地总结了我们在整本书中学到的关于 Amazon SageMaker Studio 的内容。Amazon SageMaker Studio 是一个专门为机器学习（ML）构建的集成开发环境（IDE），它通过丰富的用户界面，使得使用端到端 ML 生命周期构建 ML 模型变得简单易行。在这本书的 11 章节中，代码示例和实际的 ML 应用案例中，你学习了如何使用 SageMaker Studio 以及许多 SageMaker 功能来准备数据、构建、训练、部署 ML 模型，以及运行一个适用于生产级 ML 项目的 MLOps 系统。现在，你可以在 Amazon SageMaker Studio 中开始构建自己的 ML 项目了。