亚马逊-Redshift-无服务器机器学习-全-

亚马逊 Redshift 无服务器机器学习（全）

原文：annas-archive.org/md5/0510bb54fffc069069112c3c7905bce9

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Amazon Redshift Serverless 允许组织快速并以经济高效的方式运行 PB 级云数据仓库，使数据科学专业人士能够高效地部署云数据仓库并利用易于使用的工具来训练模型和运行预测。本实用指南将帮助与 Amazon Redshift 数据仓库一起工作的开发人员和数据专业人士将他们的 SQL 知识应用于训练和部署机器学习模型。

本书首先帮助您探索 Redshift Serverless 的内部工作原理以及数据分析的基础和数据机器学习的类型。通过逐步解释基本概念和实际示例，您将学习如何构建自己的分类和回归模型。随着您的进步，您将了解如何使用熟悉的 SQL 代码部署各种类型的机器学习项目，然后深入探讨 Redshift ML。在最后一章中，您将发现实施与 Redshift 结合的最佳实践。

在本书结束时，您将能够配置和部署 Amazon Redshift Serverless，使用 Amazon Redshift ML 训练和部署机器学习模型，并运行大规模的推理查询。

本书面向的对象

使用 Amazon Redshift 并希望探索其机器学习功能的数据科学家和机器学习开发者会发现这本 definitive guide 非常有帮助。需要具备对

要充分利用本书，需要具备机器学习技术和 Amazon Redshift 的实际操作知识。

本书涵盖的内容

第一章**，Amazon Redshift Serverless 简介，概述了 Amazon Redshift 和 Redshift Serverless，指导您如何在几分钟内开始使用并使用 Redshift Query Editor v2 进行连接。您将创建一个示例数据库并使用笔记本功能运行查询。

第二章**，在 Redshift Serverless 上数据加载和分析，帮助您学习不同的机制来高效地将数据加载到 Redshift Serverless 中。

第三章**，在您的数据仓库中应用机器学习，介绍了机器学习及其在数据仓库中应用的常见用例。

第四章**，利用 Amazon Redshift 机器学习，基于第三章。在这里，我们深入探讨 Amazon Redshift ML，了解其工作原理以及如何利用它来解决用例。

第五章**，构建您的第一个机器学习模型，让您亲自动手使用 Amazon Redshift ML 并使用简单的CREATE MODEL语法构建第一个模型。

第六章**，构建分类模型，涵盖了分类问题以及您可以在 Amazon Redshift ML 中使用来解决这些问题的算法，并学习如何在用户指导下创建模型。

第七章**，构建回归模型，帮助您确定问题是否涉及回归，并探讨了 Amazon Redshift ML 中用于训练和构建回归模型的不同方法。

第八章**，使用 K-Means 聚类构建无监督模型，展示了如何使用未标记的数据构建机器学习模型，并使用 K-means 聚类在观测级别进行预测。

第九章**，使用 Redshift ML 进行深度学习，涵盖了在 Amazon Redshift ML 中使用 MLP 模型类型对非线性可分数据进行深度学习的使用。

第十章**，使用 XGBoost 创建自定义 ML 模型，展示了如何使用 Amazon Redshift ML 的自动关闭选项来准备数据，以便构建自定义模型。

第十一章**，在数据库推理中使用您自己的模型，超越了 Redshift ML 模型。到目前为止，本书中我们将仅在 Amazon Redshift ML 中直接构建的模型上运行推理查询。本章展示了您如何利用在 Amazon Redshift ML 之外构建的模型，并在 Amazon Redshift ML 内部执行推理查询。

第十二章**，在数据仓库中进行时间序列预测，深入探讨了使用 Amazon Forecast 与 Amazon Redshift ML 的集成进行预测和时间序列数据。

第十三章**，操作和优化 Amazon Redshift ML 模型，通过展示刷新模型、创建模型版本以及优化 Amazon Redshift ML 模型的技术来结束本书。

为了充分利用本书

您需要访问 AWS 账户来执行本书中的代码示例。您要么需要管理员访问权限，要么需要与管理员合作创建用于本书的 Redshift Serverless 数据仓库以及 IAM 用户、角色和策略。

本书涵盖的软件/硬件	操作系统要求
AWS CLI（可选）	Windows、macOS 或 Linux

如果您使用的是本书的电子版，我们建议您亲自输入代码或从本书的 GitHub 仓库（下一节中提供链接）获取代码。这样做将有助于您避免与代码复制和粘贴相关的任何潜在错误 。

下载示例代码文件

您可以从 GitHub 下载此书的示例代码文件github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift。如果代码有更新，它将在 GitHub 仓库中更新。

我们还有其他来自我们丰富的书籍和视频目录的代码包可供选择，请访问github.com/PacktPublishing/。查看它们！

使用的约定

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

文本中的代码: 表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个示例：“将下载的WebStorm-10*.dmg磁盘映像文件作为系统中的另一个磁盘挂载。”

代码块设置如下：

cnt = client.execute_statement(Database='dev',
    Sql='Select count(1) from chapter2.orders;',
    WorkgroupName=REDSHIFT_WORKGROUP)
query_id = cnt["Id"]

当我们希望您注意代码块中的特定部分时，相关的行或项目将以粗体显示：

SHOW MODEL chapter5_buildfirstmodel.customer_churn_model;

任何命令行输入或输出都应如下编写：

$ pip install pandas

粗体: 表示新术语、重要单词或屏幕上看到的单词。例如，菜单或对话框中的单词以粗体显示。以下是一个示例：“从管理面板中选择系统信息。”

小贴士或重要提示

看起来是这样的。

联系我们

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

一般反馈: 如果您对此书的任何方面有疑问，请通过 mailto:customercare@packtpub.com 发送电子邮件，并在邮件主题中提及书名。

勘误: 尽管我们已经尽一切努力确保内容的准确性，但错误仍然可能发生。如果您在此书中发现错误，我们将不胜感激，如果您能向我们报告，我们将不胜感激。请访问www.packtpub.com/support/errata并填写表格。

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

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

分享您的想法

读完《使用 Amazon Redshift ML 的无服务器机器学习》后，我们非常乐意听到您的想法！请点击此处直接进入此书的 Amazon 评论页面并分享您的反馈。

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

下载此书的免费 PDF 副本

感谢您购买此书！

您喜欢在路上阅读，但无法随身携带您的印刷书籍吗？您的电子书购买是否与您选择的设备不兼容？

别担心，现在，每购买一本 Packt 书籍，您都可以免费获得该书的 DRM 免费 PDF 版本。

在任何地方、任何设备上阅读。从您最喜欢的技术书籍中搜索、复制和粘贴代码到您的应用程序中。

优惠远不止这些，您还可以获得独家折扣、时事通讯和每日免费内容的每日电子邮件。

按照以下简单步骤获取优惠：

1. 扫描下面的二维码或访问以下链接

https://packt.link/free-ebook/978-1-80461-928-5

1. 提交您的购买证明

2. 就这样！我们将直接将您的免费 PDF 和其他优惠发送到您的电子邮件。

第一部分：Redshift 概述：开始使用 Redshift Serverless 和机器学习简介

在整个组织中获得机器学习的益处需要访问数据、易于使用的工具以及内置算法，无论个人在机器学习方面的经验水平如何，任何人都可以使用。

第一部分展示了开始使用 Amazon Redshift Serverless 和 Amazon Redshift ML 是多么容易，而无需管理数据仓库基础设施。

在第一部分结束时，您将了解如何使用 Query Editor v2 笔记本运行查询以及将数据加载到 Amazon Redshift Serverless 的不同技术。然后，您将介绍机器学习，并了解您如何在数据仓库中使用机器学习。

本部分包括以下章节：

• 第一章**，Amazon Redshift Serverless 简介

• 第二章**，在 Redshift Serverless 上数据加载和分析

• 第三章**，在您的数据仓库中应用机器学习

第一章：亚马逊 Redshift 无服务器简介

“嗨，什么是数据仓库？” 约翰·多伊，虚构的葡萄酒电子商务公司 Red.wines 的 CEO 和联合创始人，问塔西亚·维什莱斯克，公司的 CTO。拥有精品酒庄的约翰与塔西亚合作了这个项目。公司在疫情期间的成功得益于社交媒体和居家趋势。约翰希望进行详细的数据分析，以调整库存和客户接触。然而，有一个问题——产生这种分析正在减缓他们的在线事务处理（OLTP）数据库。

“数据仓库就像一个大型数据库，我们在这里长期存储不同的数据，以便发现洞察和做出决策，”塔西亚解释道。

约翰有所顾虑，“听起来很贵；我们已经在为未使用的仓库空间付费了。我们负担得起吗？”

塔西亚安慰他说，“你说得对，但是有像亚马逊 Redshift 无服务器这样的云数据仓库，让你按使用付费。”

在此基础上，本章介绍了数据仓库和亚马逊 Redshift。我们将涵盖亚马逊 Redshift 无服务器基础，例如命名空间和工作组，并指导您创建数据仓库。亚马逊 Redshift 可以从各种来源收集数据，主要是亚马逊简单存储服务（S3）。

在我们阅读本章的过程中，您将了解这一关键方面，即从 S3 加载数据所需的 AWS 身份和访问管理（IAM）角色。此角色连接到您的无服务器命名空间，以便顺利传输数据。您还将了解如何使用亚马逊 Redshift 查询编辑器加载数据样本并运行查询。我们的目标是使其简单易行，以便您在这次旅程中充满信心。

Tathya Vishleshak

“Tathya Vishleshak”这个短语可以大致理解为梵文/印地语中数据分析师的概念。然而，重要的是要注意，这并不是一个精确或已建立的翻译，而是一种尝试，基于梵文中“Tathya”和“Vishleshak”的个别含义传达相似的意义。

此外，亚马逊 Redshift 用于分析数据仓库、操作数据库和数据湖中的结构化和非结构化数据。它用于传统数据仓库、商业智能、实时分析和机器学习/预测分析。数据分析师和开发人员使用带有机器学习（ML）模型的 Redshift 数据执行预测客户行为等任务。亚马逊 Redshift ML 通过使用熟悉的 SQL 命令简化了这一过程。

本书深入探讨机器学习（ML），解释了监督学习和无监督学习。您将通过实际案例学习如何使用二分类、多分类和回归进行问题解决。您还将了解如何使用 XGBoost 创建深度学习模型和自定义模型，以及如何使用时间序列预测。本书还涵盖了使用现有模型在数据库和远程进行推理，应用机器学习进行预测分析，以及实现机器学习模型。

本章将涵盖以下主题：

• 什么是 Amazon Redshift？

• 开始使用 Amazon Redshift Serverless

• 连接到您的数据仓库

本章需要网络浏览器和 AWS 账户访问权限。

什么是 Amazon Redshift？

组织会产生大量客户数据，以及这些客户与业务互动的见解。这些数据被导入各种应用程序并存储在孤立的系统中。当试图解读这些数据孤岛时，会出现一个难题——这是一个巨大的挑战，阻碍了获取对组织清晰度至关重要的有意义的见解。更复杂的是，安全和性能考虑通常使商业分析师无法访问 OLTP 系统中的数据。

但问题是复杂的分析查询会拖累 OLTP 数据库，给其核心操作蒙上阴影。在这里，解决方案是数据仓库，这是一个经过精心整理的数据中心，由商业分析师和数据科学家使用，他们通过利用可用的商业智能和机器学习工具来做出明智的决策。这些用户利用结构化查询语言（SQL）从这些数据宝库中提取洞察。从运营系统、应用程序日志和社交媒体流到物联网设备生成数据的涌入，客户将结构化和半结构化数据导入组织的数据库仓库，如图图 1.1所示，展示了传统数据仓库的经典架构。

图 1.1 – 数据仓库

正是在这里，Amazon Redshift Serverless 发挥了作用。它是 Amazon Redshift 中的一个关键选项，由亚马逊网络服务（AWS）提供的由云管理的数据仓库。凭借基于云的便捷性，Amazon Redshift Serverless 让您无需基础设施烦恼或成本担忧即可设置数据存储。您根据使用的计算和存储付费。

Amazon Redshift Serverless 不仅提供了便利，还推动了现代数据应用，这些应用可以无缝连接到数据湖。进入数据湖——一个结构，它将所有数据流汇聚在一起，提供无限空间以任何规模、经济高效地存储数据。与其他数据存储库，如数据仓库一样，数据湖重新定义了组织处理数据的方式。这正是所有这一切汇聚的地方——以下图表显示了 Amazon Redshift Serverless 如何将 SQL 驱动的查询注入数据湖，驱动动态数据流：

图 1.2 – 数据湖和数据仓库

那么，让我们开始创建我们第一个云数据仓库吧！

开始使用 Amazon Redshift Serverless

您可以使用顶栏中的Redshift创建您的数据仓库，如图图 1.3所示：

图 1.3 – AWS 控制台页面显示通过我们的 Redshift 搜索过滤出的服务

点击Amazon Redshift，这将带您到 Amazon Redshift 控制台的主页，如图图 1.4所示。为了帮助您开始，Amazon 为首次使用 Redshift Serverless 的客户提供免费信用额度。因此，让我们通过点击尝试 Amazon Redshift Serverless来开始创建您的试用数据仓库。如果您或您的组织之前已经尝试过 Amazon Redshift Serverless，您将需要根据您的使用情况支付服务费用：

图 1.4 – AWS 控制台中的 Amazon Redshift 服务页面

如果你有可用的免费信用额度，它将在屏幕顶部显示，如图图 1.5所示：

图 1.5 – AWS 控制台显示 Redshift Serverless 入门页面

您可以选择默认设置或使用自定义设置来创建您的数据仓库。自定义设置为您提供更多控制权，允许您为计算配置指定许多其他参数，包括工作组、与数据相关的设置，如命名空间，以及高级安全设置。我们将使用自定义设置，这将帮助我们自定义 Serverless 数据仓库的命名空间设置。命名空间与工作组的结合是 Redshift Serverless 数据仓库的要素，正如我们现在将更详细地看到的那样。

命名空间是什么？

Amazon Redshift Serverless 为数据仓库提供了存储和计算的分离。命名空间 是您在数据库中存储的所有数据的集合，例如您的表、视图、数据库用户及其权限。您将根据存储在您的数据仓库中数据的存储大小分别计费。对于计算，您将根据在 Redshift 处理小时（RPU）中使用的容量按秒计费。存储容量按 Redshift 管理存储（RMS）计费，并按 GB/月计费。您可以在 aws.amazon.com/redshift/pricing/ 查看您 AWS 区域的详细定价信息。

作为数据仓库管理员，您可以在创建命名空间时更改您的数据仓库命名空间名称。您还可以更改您的加密设置、审计日志和 AWS IAM 权限，如图 图 1**.6 所示。我们将使用自定义设置的主要原因是为了将 IAM 角色与命名空间关联：

图 1.6 – 命名空间配置

AWS IAM 允许您指定哪些用户或服务可以访问 AWS 中的其他服务和资源。我们将使用该角色从 S3 加载数据，并使用 Redshift ML 训练机器学习模型，该模型访问 Amazon SageMaker。

如果您之前已经创建了一个 IAM 角色，您可以将它关联到该 IAM 角色。如果您还没有创建 IAM 角色，请现在通过选择如图 图 1**.7 所示的 “管理 IAM 角色” 选项来创建它：

图 1.7 – 通过 AWS 控制台创建 IAM 角色并将其关联

然后，选择如图 图 1**.8 所示的 “创建 IAM 角色” 选项：

图 1.8 – 选择“创建 IAM 角色”选项

然后，您可以创建一个默认 IAM 角色并为 IAM 角色提供适当的权限，以便它能够访问 S3 存储桶，如图 图 1**.9 所示：

图 1.9 – 授予 IAM 角色 S3 权限

如前图所示，选择 任何 S3 存储桶 以启用 Redshift 从您创建的所有 S3 存储桶中读取和写入数据。然后，选择 创建 IAM 角色作为默认角色 以创建角色并将其设置为默认 IAM 角色。

图 1.10 – 已创建 IAM 角色，但尚未应用

如 图 1**.10 所示，我们已创建 IAM 角色并将其作为默认角色关联到命名空间。接下来，我们将继续创建一个工作组，在该工作组中我们将设置数据仓库的计算配置。

工作组是什么？

如我们之前讨论的，命名空间与工作组的组合构成了 Redshift Serverless 数据仓库。工作组提供了处理您的数据所需的计算资源。它还提供了您连接到仓库的端点。作为管理员，您需要配置工作组的计算设置，例如网络和安全配置。

我们现在不会进行任何自定义，而是简单地选择默认设置，包括工作组的 VPC 和相关子网，如图所示：

图 1.11 – 工作组默认设置和相关子网

点击 保存配置 按钮以创建您的 Redshift Serverless 实例，您的第一个数据仓库将在几分钟内准备就绪：

图 1.12 – Redshift Serverless 创建进度

一旦您的数据仓库准备就绪，您将被重定向到您的 Serverless 仪表板，如图 图 1**.13 所示：

图 1.13 – 显示您的命名空间和工作组的服务器无仪表板

现在我们已经创建了我们的数据仓库，我们将连接到数据仓库，加载一些示例数据，并运行一些查询。

连接到您的数据仓库

使用 Redshift Serverless 的您的数据仓库现在已准备就绪。您可以通过 JDBC/ODBC/Python 驱动程序使用第三方工具连接到您的数据仓库。其他选项包括 数据 API 或内嵌的 Redshift 查询编辑器 v2。

使用 Amazon Redshift 查询编辑器 v2

现在您的数据仓库已准备就绪；让我们导航到查询编辑器，加载一些示例数据并运行一些查询。从您的仪表板中选择 查询数据 选项，如图 图 1**.13 所示，您将被导航到查询编辑器，如图 图 1**.14 所示。

图 1.14 – 查询编辑器

在 Redshift 查询编辑器 v2 控制台中，在左侧面板中，您将看到您有权访问的数据仓库，例如 Serverless:default 工作组。点击工作组（Serverless:default）以连接到数据仓库。

图 1.15 – 创建到您工作组的连接

如前述截图所示，如果在创建命名空间时未指定任何数据库凭据，请选择联邦用户，然后点击创建连接。您可以将数据库名称保留为dev。您只需在首次连接到数据仓库时创建连接。如果您已创建连接，则在点击工作组时将自动连接。一旦连接，您将在导航器中看到数据库，如图 图 1**.16 所示：

图 1.16 – 数据库列表

由于我们刚刚首次创建了数据仓库，其中没有数据，所以现在让我们将一些样例数据加载到数据仓库中。

加载样例数据

在左侧面板中，单击sample_data_dev数据库以展开可用的数据库：

图 1.17 – 显示可用样例数据的 Redshift 查询编辑器 v2 导航器

如前述截图所示，有三个样例数据集可供您加载到您的数据仓库中。单击您选择的样例数据笔记本右侧带有箭头的文件夹图标以加载和打开它，如图 图 1**.18 所示：

图 1.18 – 样例数据库列表

您将被提示创建您的样例数据库。单击创建以开始，如图 图 1**.19 所示：

图 1.19 – 创建样例数据库

样例数据将在几秒钟内加载，并以 SQL 查询笔记本的形式呈现，您可以探索数据集，如图 图 1**.20 所示：

图 1.20 – tickit 数据库的样例查询笔记本

您可以展开查询编辑器左侧的导航树以查看架构和数据库对象，例如您架构中的表和视图，如图 图 1**.21 所示。

图 1.21 – 展开导航树以查看架构和数据库对象

您可以单击表以查看表定义，如图 图 1**.22 所示：

图 1.22 – 表定义

右键单击表提供额外的选择表、显示表定义和删除选项，如图 图 1**.23 所示：

图 1.23 – 右键单击表以查看更多选项

你可以点击运行全部，如图图 1.24所示，来运行示例笔记本中的所有查询。查询编辑器提供了一个笔记本界面来添加注释，SQL 单元格将你的查询组织在一个文档中。你可以用于文档目的的注释。

图 1.24 – “运行全部”选项

你将看到每个单元格的查询结果。你可以将结果下载为 JSON 或 CSV 文件到你的桌面，如图图 1.25所示：

图 1.25 – 下载查询结果选项

让我们编写我们的第一个查询。

运行你的第一个查询

我们想要找出tickit数据库中按销售额排名前 10 的事件。我们将在数据仓库中运行以下 SQL 语句：

SELECT eventname, total_price
FROM  (SELECT eventid, total_price, ntile(1000) over(order by total_price desc) as percentile
       FROM (SELECT eventid, sum(pricepaid) total_price
             FROM   tickit.sales
             GROUP BY eventid)) Q, tickit.event E
       WHERE Q.eventid = E.eventid
       AND percentile = 1
ORDER BY total_price desc
limit 10;

在查询编辑器中，通过点击+符号并从出现的菜单中选择编辑器来添加一个新的查询。如果你想要创建一个新的笔记本，你可以点击笔记本，如图图 1.26所示：

图 1.26 – 创建新查询

现在，在编辑器中输入前面的 SQL 查询，然后点击运行。你将得到以下截图所示的结果：

图 1.27 – 带结果的查询

正如俗话所说，“一图胜千言”，查询编辑器允许你可视化结果以获得更快的洞察。你可以通过点击图表选项然后选择你想要的图表来轻松创建图表。让我们选择一个散点图，如图图 1.28所示：

图 1.28 – 在 Redshift 查询编辑器 v2 中使用图表

你可以为 X 轴和 Y 轴添加图表名称和注释，并将图表导出为 PNG 或 JPG 格式，用于演示文稿或与业务伙伴分享：

图 1.29 – 查询编辑器 v2 中的图表选项

如你所见，你可以使用 Redshift 查询编辑器 v2 创建自己的数据库，创建表，加载数据，运行和编写查询和笔记本。你可以与团队成员分享你的查询和笔记本。

摘要

在本章中，你学习了关于云数据仓库和 Amazon Redshift Serverless 的内容。你创建了第一个由 Redshift Serverless 提供动力的数据仓库，并使用查询编辑器加载了一些示例数据。你还学习了如何使用查询编辑器运行查询和可视化数据以产生洞察。

在第二章中，你将学习在 Amazon Redshift Serverless 数据仓库中加载数据和执行分析的最佳技术。

第二章：在 Redshift Serverless 上加载数据和分析

在上一章中，我们向您介绍了Amazon Redshift Serverless，并演示了如何从 Amazon Redshift 控制台创建无服务器端点。我们还解释了如何使用Amazon Redshift 查询编辑器 v连接和查询您的数据仓库。在本章中，我们将更深入地探讨您可以将数据加载到 Amazon Redshift Serverless 数据仓库的不同方法。

在本章中，我们将涵盖三个主要主题，以帮助您高效地将数据加载到 Redshift Serverless 中。首先，我们将演示如何使用 Amazon Redshift 查询编辑器 v 加载数据，您将学习如何使用 GUI 将数据从您的 Amazon S3 存储桶和本地数据文件加载到您的计算机上。

接下来，我们将详细探讨COPY命令，您将学习如何通过编写COPY命令来加载数据。我们将涵盖您需要了解的所有内容，以有效地使用此命令并将数据顺利加载到 Redshift Serverless 中。

最后，我们将介绍内置的本地 API 接口，使用 Jupyter Notebook 访问和将数据加载到您的 Redshift Serverless 端点。我们将指导您完成设置和使用Redshift 数据 API的过程。

主题如下：

• 使用 Amazon Redshift 查询编辑器 v 加载数据

• 使用 COPY 命令从 Amazon S3 加载数据

• 使用 Redshift 数据 API 加载数据

本章的目标是让您掌握使用不同机制将数据加载到 Amazon Redshift Serverless 的知识和技能。到本章结束时，您将能够使用本章介绍的方法快速有效地将数据加载到 Redshift Serverless 中，这将使您能够对数据进行分析并提取有价值的见解。

技术要求

本章需要网络浏览器以及访问以下内容：

• 一个 AWS 账户

• Amazon Redshift

• Amazon Redshift 查询编辑器 v2

• Amazon SageMaker for Jupyter Notebook

本章中的代码片段可在本书的 GitHub 仓库中找到：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/CodeFiles/chapter2.

本章中使用的数据文件可以在本书的 GitHub 仓库中找到：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/DataFiles/chapter2.

使用 Amazon Redshift 查询编辑器 v2 加载数据

Query Editor v2 支持不同的数据库操作，包括 数据定义语言 (DDL)，只需点击一下按钮即可创建架构和表，并从数据文件中加载数据。让我们看看如何执行这些任务，以便在您的数据仓库上轻松进行数据分析。登录到您的 AWS 控制台，导航到您的 Amazon Redshift Serverless 端点，并选择 查询数据。这将在新标签页中打开 Redshift 查询编辑器 v2。按照我们在 第一章 中遵循的步骤，登录到您的数据库并执行以下小节中概述的任务。

创建表

Query editor v2 提供了一个向导来执行图 图 2**.1 中显示的 DDL 命令。首先，让我们创建一个名为 chapter2 的新架构：

1. 点击 创建 并选择 架构，如图所示。

图 2.1 – 创建向导

确保您的 chapter2。

1. 然后，点击 创建架构，如图 图 2**.2 所示。

图 2.2 – 创建架构

一旦创建了架构，导航到 customer 中的 chapter2。使用 Query Editor v2，您可以手动输入列名及其数据类型，或者可以使用数据文件自动推断列名及其数据类型。

让我们使用数据文件创建一个表。我们将使用 customer.csv，该文件可在本书的 GitHub 仓库中找到，网址为 github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/DataFiles/chapter2。您可以将此文件本地下载以使用向导创建表。

该文件包含 TPC-H 数据集的子集，可在本书的 GitHub 仓库中找到：github.com/awslabs/amazon-redshift-utils/tree/master/src/CloudDataWarehouseBenchmark/Cloud-DWB-Derived-from-TPCH。

在 创建表 向导中，在 列 选项卡下点击 从 CSV 加载，并提供 CSV 文件的路径。一旦选择了文件，架构将从文件中推断并自动填充，如图 图 2**.3 所示。可选地，您可以在 列名、数据类型和编码字段中修改架构，在列选项下，您可以选择以下选项：

• 为列选择一个默认值。

• 可选地，如果您想使列值递增，可以打开 自动递增。如果启用此选项，则可以指定 自动递增种子 和 自动递增步长 的值。

• 为列输入一个大小值。

• 您还可以定义约束，例如 非空、主键和唯一键。

图 2.3 – 创建表

此外，如图图 2.4 所示，在表详情选项卡下，您可以可选地设置表属性，例如分布键、分布样式、排序键和排序类型。当这些选项未设置时，Redshift 将为您选择默认设置，即自动分布键和自动 排序键。

图 2.4 – 表详情

Amazon Redshift 根据表的分布样式（DISTSTYLE）在表中分布数据。数据行根据每个计算节点上的切片数量在各个计算节点内分布。当您对表运行查询时，计算节点的所有切片并行处理分配的行。作为一个最佳实践（docs.aws.amazon.com/redshift/latest/dg/c_best-practices-best-dist-key.html），选择表的DISTSTYLE参数以确保数据的均匀分布，或使用自动分布。

Amazon Redshift 使用表的排序键在每个切片内排序数据。Amazon Redshift 还允许您定义具有复合排序键、交错排序键或没有排序键的表。作为一个最佳实践（docs.aws.amazon.com/redshift/latest/dg/c_best-practices-sort-key.html），根据您的数据访问模式定义排序键和样式。在表上定义适当的排序键可以极大地提高您的查询性能。

最后，在其他选项下，您可以选择以下内容：

• 是否将您的表包含在自动和手动快照中

• 是否创建基于会话的临时表而不是永久数据库表

一旦您已输入所有详细信息，您可以通过单击在编辑器中打开查询来查看您表的 DDL。您可以使用它稍后或甚至与其他用户共享。

现在，让我们通过单击创建表按钮（图 2**.4）来创建我们的表。

如您所见，任何数据科学家、分析师或用户都可以使用此向导创建数据库对象（如表），而无需编写 DDL 或输入每一列的数据类型及其长度。

现在，让我们在客户表中加载数据。查询编辑器 v2 允许您从 Amazon S3 或您计算机上的本地文件加载数据。请注意，在撰写本文时，加载本地文件选项目前仅支持最大大小为 5 MB 的 CSV 文件。

从 Amazon S3 加载数据

查询编辑器 v2 允许您将 Amazon S3 存储桶中的数据加载到现有的 Redshift 表中。

COPY命令，它真正使数据分析师或数据科学家的工作变得更简单，因为他们不需要记住COPY命令的复杂性。您可以使用COPY命令支持的多种文件格式加载数据，例如 CSV、JSON、Parquet、Avro 和 Orc。有关所有支持的数据格式，请参阅此链接：docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-format.html#copy-format。

让我们看看如何使用customer.csv加载数据，该文件存储在以下 Amazon S3 位置：s3://packt-serverless-ml-redshift/chapter02/customer.csv。

注意，如果您想使用自己的 Amazon S3 存储桶来加载数据，那么请从技术要求部分中提到的 GitHub 位置下载数据文件。

要从 GitHub 下载数据文件，导航到您的仓库，选择文件，在文件顶部右键单击查看原始文件按钮，选择另存为…（如以下截图所示），选择您要在计算机上保存文件的路径，然后选择保存：

图 2.5 – 保存数据文件

在查询编辑器 v2 中，单击加载数据，这将打开数据加载向导。

在数据源下，选择从 S3 加载单选按钮。您可以在您的账户中浏览 S3 存储桶以选择要加载数据的文件或文件夹，或者您可以选择一个清单文件。对于这个练习，粘贴上述 S3 文件位置。

如果数据文件位于与您的 Amazon Redshift Serverless 不同的区域，您可以从 S3 文件位置下拉菜单中选择源区域。如果您想加载 Parquet 文件，向导会提供不同的选项。然后，从文件格式选项中选择一个选项，或者在文件选项下，如果您数据由不同的字符分隔，可以选择分隔符。如果您的文件已压缩，您可以从下拉菜单中选择适当的压缩方式，例如gzip、lzop、zstd或bzip2。

在高级设置下，请注意有两个选项，数据转换参数和加载操作：

• 在TIMEFORMAT)中将它设置为‘MM.DD.YYYY HH:MI:SS'。有关完整参数列表，请参阅此文档链接：docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html#copy-timeformat。

• 在COMPROWS)中将它设置为1,000,000。有关完整选项列表，请参阅此文档：docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-load.html。

由于我们的文件包含标题行，请确保在 高级设置 | 数据转换参数 | 常用参数 下，忽略标题行（作为 1） 选项被选中。

如 图 2.6 所示，选择 目标表 参数和 IAM 角色 以加载数据：

图 2.6 – 加载数据

一旦您在编辑器中点击 COPY 命令并运行 COPY 语句开始加载。

现在我们已经加载数据，让我们快速验证加载并查询表来检查数据，如下所示：

图 2.7 – 查询数据

Query Editor v2 允许您在编辑器中保存查询以供以后使用。您可以通过点击 COPY 命令）在将来执行，假设目标表相同，但 Amazon S3 上的数据位置不同，那么您可以轻松修改此查询并快速加载数据。或者，您甚至可以将查询参数化，例如，将 S3 位置作为 ${s3_location} 传递，如 图 2.8 所示：

图 2.8 – 保存查询

分享查询

使用 Query Editor v2，您可以与您的团队共享您保存的查询。这样，许多用户可以协作并共享相同的查询。内部，Query Editor 管理查询版本，因此您可以跟踪更改。有关更多信息，请参阅此 AWS 文档：docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-team.html#query-editor-v2-query-share。

现在我们已经介绍了 Query Editor v2 如何通过点击几个按钮的 UI 界面轻松创建数据库对象并加载数据，让我们深入了解 Amazon Redshift 的 COPY 命令，以便将数据加载到您的数据仓库中。

从本地驱动器加载数据

Query Editor v2 允许用户从他们的计算机上的本地文件加载数据并进行快速分析。通常，数据库用户如数据分析师或数据科学家在他们的本地计算机上拥有他们想要快速加载到 Redshift 表中的数据文件，而无需将文件移动到远程位置，如 Amazon S3。

为了从本地文件加载数据，Query Editor v2 要求在您的账户中配置一个暂存 Amazon S3 存储桶。如果没有配置，您将看到类似于以下截图中的错误：

图 2.9 – 错误消息

为了避免前面的错误，用户必须进行以下配置：

1. 账户用户必须配置适当的权限，如下所示。将以下策略附加到您的 Redshift Serverless IAM 角色。替换高亮显示的资源名称：

   {
   

       "Version": "2012-10-17",
   

       "Statement": [
   

           {
   

               "Effect": "Allow",
   

               "Action": [
   

                   "s3:ListBucket",
   

                   "s3:GetBucketLocation"
   

               ],
   

               "Resource": [
   

                   "arn:aws:s3:::<staging-bucket-name>"
   

               ]
   

           },
   

           {
   

               "Effect": "Allow",
   

               "Action": [
   

                   "s3:PutObject",
   

                   "s3:GetObject",
   

                   "s3:DeleteObject"
   

               ],
   

               "Resource": [
   

                   "arn:aws:s3:::<staging-bucket-name>[/<optional-prefix>]/${aws:userid}/*"
   

               ]
   

           }
   

       ]
   

   }
   

2. 您的管理员必须在账户设置窗口中配置通用的 Amazon S3 存储桶，如图所示：

   1. 点击设置图标()并选择账户设置，如图下截图所示：

图 2.10 – 账户设置

1. 在账户设置窗口中，在常规设置 | S3 存储桶 | S3 URI下，输入将在本地文件加载期间用于暂存的 S3 存储桶的 URI，然后点击保存。确保您的 IAM 角色具有在 S3 存储桶上读取和写入的权限：

图 2.11 – 在常规设置下输入 S3 存储桶的 URI

请参阅此文档以获取完整信息：

docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-loading.html#query-editor-v2-loading-data-local

创建表并从本地 CSV 文件加载数据

让我们创建一个新的表。导航到查询编辑器 v2，并使用以下 DDL 命令创建供应商表：

CREATE TABLE chapter2.supplier (
    s_suppkey integer NOT NULL ENCODE raw distkey,
    s_name character(25) NOT NULL ENCODE lzo,
    s_address character varying(40) NOT NULL ENCODE lzo,
    s_nationkey integer NOT NULL ENCODE az64,
    s_phone character(15) NOT NULL ENCODE lzo,
    s_acctbal numeric(12, 2) NOT NULL ENCODE az64,
    s_comment character varying(101) NOT NULL ENCODE lzo,
    PRIMARY KEY (s_suppkey)
) DISTSTYLE KEY
SORTKEY (s_suppkey);

我们将从以下 GitHub 位置的数据文件(supplier.csv)将数据加载到我们的供应商表中：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/DataFiles/chapter2/supplier.csv。

要在您的本地计算机上下载文件，请右键单击原始并点击另存为。

为了从查询编辑器 v2 将数据加载到供应商表中，点击您本地驱动器上的supplier.csv文件。在目标表选项下，将模式设置为chapter2，将表设置为supplier。点击加载数据以开始加载：

图 2.12 – 加载数据向导

一旦数据成功加载，您将看到如下消息：

图 2.13 – 数据成功加载后的消息

通过运行以下 SQL 查询验证数据加载：

select * from chapter2.supplier;

您应该能够看到从文件中加载的 100 行数据：

图 2.14 – 数据加载验证

我们现在已成功从下一节的查询编辑器 v2 COPY 命令中加载数据。

使用 COPY 命令从 Amazon S3 加载数据

数据仓库通常设计用于摄取和存储大量数据，任何分析过程的关键方面之一是以最有效的方式摄取这些大量数据。加载数据可能需要很长时间，同时也会消耗大量计算资源。如前所述，有几种方法可以在您的 Redshift 无服务器数据仓库中加载数据，其中最快和最可扩展的方法之一是COPY命令。

COPY命令通过并行从文件加载数据，利用 Redshift 的大规模并行处理（MPP）架构。它可以从 Amazon S3、Amazon EMR、Amazon DynamoDB 或远程主机上的文本文件加载数据。这是在 Redshift 数据仓库中加载数据最有效的方法。通过适当的 IAM 策略，您可以安全地控制谁可以访问和加载数据库中的数据。

在前面的部分，我们看到了如何使用 Query Editor v2 生成COPY命令从向导加载数据。在本节中，我们将深入探讨如何编写COPY命令并从 Amazon S3 加载数据，以及一些最佳实践。

让我们来看看如何使用COPY命令将数据加载到您的 Redshift 数据仓库中：

COPY table-name
[ column-list ]
FROM data_source
authorization
[ [ FORMAT ] [ AS ] data_format ]
[ parameter [ argument ] [, ... ] ]

COPY命令需要三个参数：

• table-name：数据库中存在的目标表名（持久或临时）

• data_source：数据源位置（例如 S3 存储桶）

• authorization：认证方法（例如 IAM 角色）

默认情况下，COPY命令的源数据格式预期为以字符分隔的 UTF-8 文本文件，默认分隔符为管道字符（|）。如果您的源数据是其他格式，您可以将其作为参数传递以指定数据格式。Amazon Redshift 支持不同的数据格式，如固定宽度文本文件、字符分隔文件、CSV、JSON、Parquet 和 Avro。

此外，COPY命令提供了可选参数来处理数据转换，例如数据格式、null和编码。要获取最新详细信息，请参阅此 AWS 文档：docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax。

从 Parquet 文件加载数据

在前面的部分，我们尝试将 CSV 文件加载到我们数据库中的客户表中。为此练习，让我们尝试加载一种列式数据格式文件，如 Parquet。我们将使用TPC-H数据的一个子集，可能在这里找到：github.com/awslabs/amazon-redshift-utils/tree/master/src/CloudDataWarehouseBenchmark/Cloud-DWB-Derived-from-TPCH/3TB。

TPC 是一个专注于开发数据基准标准的组织。您可以在www.tpc.org/default5.asp了解更多关于 TPC 的信息。

修改后的数据（lineitem.parquet）可在 GitHub 上找到：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/DataFiles/chapter2。

COPY命令所需的数据在此处可用：s3://packt-serverless-ml-redshift/chapter02/lineitem.parquet。

此文件包含大约 600 万行，大小约为 200 MB：

1. 让我们先从在chapter2模式中创建一个名为lineitem的表开始：

   -- Create lineitem table
   

   CREATE TABLE chapter2.lineitem
   

   (l_orderkey     bigint,
   

   l_partkey       bigint,
   

   l_suppkey       integer,
   

   l_linenumber    integer,
   

   l_quantity      numeric(12,2),
   

   l_extendedprice numeric(12,2),
   

   l_discount      numeric(12,2),
   

   l_tax           numeric(12,2),
   

   l_returnflag    character(1),
   

   l_linestatus    character(1),
   

   l_shipdate      date,
   

   l_commitdate    date,
   

   l_receiptdate   date,
   

   l_shipinstruct  character(25),
   

   l_shipmode      character(10),
   

   l_comment       varchar(44))
   

   distkey(l_orderkey) compound sortkey(l_orderkey,l_shipdate);
   

2. 现在，让我们使用COPY命令从lineitem.parquet文件加载数据：

   COPY chapter2.lineitem
   

   FROM 's3://packt-serverless-ml-redshift/chapter02/lineitem.parquet'
   

   IAM_ROLE default
   

   FORMAT AS PARQUET;
   

现在我们已经加载数据，让我们快速验证加载并查询表来检查数据，如下面的截图所示：

图 2.15 – 查询表

在本节中，我们讨论了COPY命令如何帮助您从 Amazon S3 存储桶加载数据，例如 CSV、Parquet 和 JSON 格式。让我们看看您如何自动化COPY命令，以便在 Amazon S3 存储桶中数据可用时立即加载数据。撰写本文时，自动化COPY作业的下一节正处于公开预览阶段。

使用COPY作业自动化文件摄取

在您的数据仓库中，数据持续从 Amazon S3 摄取。之前，您通过外部或本地编写自定义代码，并使用调度工具来实现这种持续的数据摄取。借助 Amazon Redshift 的自动复制功能，用户可以轻松自动化从 Amazon S3 到 Amazon Redshift 的数据摄取。为此，您将编写一个简单的 SQL 命令来创建COPY作业（docs.aws.amazon.com/redshift/latest/dg/r_COPY-JOB.html），并且当它检测到源 Amazon S3 路径中的新文件时，COPY命令将自动触发。这将确保用户在数据到达 S3 路径后不久即可获得最新数据以进行处理，而无需构建外部自定义框架。

要开始，您可以设置一个COPY作业，如下所示，或者通过添加JOB CREATE参数来修改现有的COPY命令：

COPY <table-name>
FROM 's3://<s3-object-path>'
[COPY PARAMETERS...]
JOB CREATE <job-name> [AUTO ON | OFF];

让我们分解一下：

• job-name是作业的名称

• AUTO ON | OFF表示从 Amazon S3 加载数据是否自动加载到 Amazon Redshift 表中

如您所见，COPY作业是COPY命令的扩展，并且默认启用了COPY作业的自动摄取。

如果你想运行一个COPY作业，你可以通过运行以下命令来完成：

COPY JOB RUN job-name

对于最新详情，请参阅此 AWS 文档：docs.aws.amazon.com/redshift/latest/dg/loading-data-copy-job.html。

COPY命令的最佳实践

以下最佳实践将帮助您充分利用COPY命令：

• 通过将数据分割成多个压缩文件或在目标表上定义分布键来充分利用并行处理，就像我们在示例中所做的那样。

• 使用单个 COPY 命令从多个文件加载数据。如果你使用多个并发 COPY 命令从多个文件加载数据到同一个目标表，那么加载数据是串行的，这比单个 COPY 命令慢得多。

• 如果你的数据文件包含不均匀或匹配的列数，请提供列的逗号分隔值列表。

• 当你想从多个数据文件加载数据到单个目标表，并且你的数据文件具有相似的结构但不同的命名约定，或者位于 Amazon S3 桶的不同文件夹中时，请使用清单文件。你可以在一个 JSON 格式的文本文件中提供要加载的文件的完整路径。以下是如何使用清单文件的语法：

  copy <table_name> from 's3://<bucket_name>/<manifest_file>'
  

  authorization
  

  manifest;
  

• 对于 COPY 作业，为每个要加载的文件使用唯一的文件名。如果文件已经被处理，并且在此之后进行了任何更改，那么 COPY 作业将不会处理该文件，所以请记住重命名更新后的文件。

到目前为止，我们已经看到了在 Amazon Redshift 数据仓库中加载数据的两种方法——使用 Query Editor v2 向导和编写单个 COPY 命令来触发临时数据加载。现在让我们看看如何使用 AWS SDK 通过 Redshift 数据 API 加载数据。

使用 Redshift 数据 API 加载数据

Amazon Redshift 数据 API 是一个内置的本地 API 接口，用于访问你的 Amazon Redshift 数据库，无需配置任何 Java 数据库连接 (JDBC) 或 开放数据库连接 (ODBC) 驱动程序。你可以通过简单的 API 端点进行数据摄取或查询，无需管理持久连接。数据 API 通过使用 IAM 临时凭证或 AWS Secrets Manager 提供了一种安全的方式来访问你的数据库。它提供了一个安全的 HTTP 端点来异步运行 SQL 语句，这意味着你可以稍后检索结果。默认情况下，你的查询结果会存储 24 小时。Redshift 数据 API 与不同的 AWS SDK 无缝集成，例如 Python、Go、Java、Node.js、PHP、Ruby 和 C++。你还可以将 API 与 AWS Glue 集成以创建 ETL 数据管道，或者使用 AWS Lambda 调用不同的 SQL 语句。

你可以利用 Redshift 数据 API 的许多用例，例如与 AWS Step Functions 的 ETL 调度、基于 Web 服务的应用程序、事件驱动应用程序，以及使用 Jupyter notebooks 访问你的 Amazon Redshift 数据库。如果你只想运行单个 SQL 语句，则可以使用 AWS 命令行界面 (AWS CLI) 或任何编程语言。以下是从 AWS CLI 在 Amazon Redshift Serverless 中执行单个 SQL 语句的示例：

aws redshift-data execute-statement
--WorkgroupName redshift-workgroup-name
--database dev
--sql 'select * from redshift_table';

注意，对于 Redshift Serverless，您只需要提供工作组名称和数据库名称。临时用户凭证从 IAM 授权中获取。对于 Redshift Serverless，请将以下权限添加到附加到您的集群 IAM 角色的 IAM 策略中，以访问 Redshift Data API：

redshift-serverless:GetCredentials

为了展示您如何使用 Redshift Data API 摄入数据，我们将使用 Jupyter Notebook 执行以下步骤。让我们在我们的 AWS 账户中创建一个笔记本实例。

在控制台主页上，搜索 Amazon SageMaker。点击左上角的汉堡图标 ()，然后 笔记本，然后 笔记本实例。点击 创建笔记本实例 并提供必要的输入。一旦笔记本实例投入使用，点击 打开 Jupyter。

以下截图显示了一个创建的笔记本实例：

图 2.16 – 创建笔记本实例

本练习的 Jupyter 笔记本可在以下 GitHub 位置找到：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/Chapter2.ipynb。请将此笔记本下载到您的本地计算机并在文件夹中保存。

本练习的数据 (orders.parquet) 可在 GitHub 上找到：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/DataFiles/chapter2，以及此 Amazon S3 位置：s3://packt-serverless-ml-redshift/chapter2/orders.parquet。

我们将使用 orders 数据的一个子集，该数据来自以下位置的 TPC-H 数据集：github.com/awslabs/amazon-redshift-utils/tree/master/src/CloudDataWarehouseBenchmark/Cloud-DWB-Derived-from-TPCH。

让我们先按照以下步骤打开下载的笔记本 (Chapter2.ipynb)：

1. 在 Jupyter Notebook 登录页面，点击 上传 并打开之前下载的笔记本。

2. 笔记本上传后，选择内核 (conda_python3)。

注意

Redshift Serverless 需要您的 boto3 版本高于 1.24.32。

1. 让我们检查我们的 boto3 库版本，如图 图 2.17 所示。

图 2.17 – 检查 boto3 版本

如果您想安装一个高于 1.24.32 的特定版本，请参考以下示例：

pip install boto3==1.26.35

创建表

正如您在 chapter2.ipynb 笔记本中看到的，我们提供了逐步说明，以连接到您的 Redshift Serverless 端点并执行必要的操作：

1. 让我们先设置参数并导入此练习所需的必要库。我们将设置以下两个参数：

   • REDSHIFT_WORKGROUP：Redshift Serverless 工作组的名称

   • S3_DATA_FILE：加载数据的源数据文件：

     import boto3
     

     import time
     

     import pandas as pd
     

     import numpy as np
     

     session = boto3.session.Session()
     

     region = session.region_name
     

     REDSHIFT_WORKGROUP = '<workgroup name>'
     

     S3_DATA_FILE='s3://packt-serverless-ml-redshift/chapter2/orders.parquet'
     

注意

记住根据 Jupyter 笔记本中的设置设置参数。

1. 为了创建表，我们首先准备我们的 DDL 并将其分配给table_ddl变量：

   table_ddl = """
   

   DROP TABLE IF EXISTS chapter2.orders CASCADE;
   

   CREATE TABLE chapter2.orders
   

   (o_orderkey     bigint NOT NULL,
   

   o_custkey       bigint NOT NULL encode az64,
   

   o_orderstatus   character(1) NOT NULL encode lzo,
   

   o_totalprice    numeric(12,2) NOT NULL encode az64,
   

   o_orderdate     date NOT NULL,
   

   o_orderpriority character(15) NOT NULL encode lzo,
   

   o_clerk         character(15) NOT NULL encode lzo,
   

   o_shippriority  integer NOT NULL encode az64,
   

   o_comment       character varying(79) NOT NULL encode lzo
   

   )
   

   distkey(o_orderkey) compound sortkey(o_orderkey,o_orderdate);"""
   

2. 使用boto3库，我们将连接到 Redshift Serverless 工作组：

   client = boto3.client("redshift-data")
   

有不同的方法可用于在 Redshift Serverless 端点上执行不同的操作。请在此文档中查看整个列表：boto3.amazonaws.com/v1/documentation/api/latest/reference/services/redshift-data.html。

1. 我们将使用execute_statement方法运行一个 SQL 语句，该语句可以是BatchExecuteStatement中的。要获取不同方法和如何使用它们的完整列表，请参阅此 AWS 文档：docs.aws.amazon.com/redshift-data/latest/APIReference/Welcome.html：

   client = boto3.client("redshift-data")
   

   res = client.execute_statement(Database='dev', Sql=table_ddl,                                   WorkgroupName=REDSHIFT_WORKGROUP)
   

如前面的代码块所示，我们首先将客户端设置为redshift-data，然后调用execute_statement连接到 Serverless 端点，使用Database名称和WorkgroupName。此方法使用临时凭证连接到你的 Serverless 工作组。

我们还将table_ddl作为参数传递以创建表。我们将在chapter2模式中创建Orders表。

1. 当操作成功时，Redshift Data API 会返回一个响应元素，以 JSON 格式作为字典对象。响应元素之一是 SQL 语句标识符。此值是全局唯一的，由 Amazon Redshift Data API 生成。如以下代码所示，我们已经从输出对象res中捕获了响应元素Id：

   query_id = res["Id"]
   

   print(query_id)
   

2. 为了确保你的查询已完成，你可以使用describe_statement方法并传递你的id语句作为参数。此方法发送响应，其中包含包括查询开始时间、完成时间、查询状态、返回的行数和 SQL 语句的信息。

图 2.18 – 检查查询状态

如图 2**.18所示，我们已经捕获了我们运行的语句的状态，并且它发送出状态为FINISHED。这意味着我们已经创建了数据库中的表，你可以通过针对该表编写一个简单的SELECT语句来验证这一点。

使用 Redshift Data API 加载数据

现在，让我们继续将数据加载到这个新创建的表中。你可以使用之前提到的 S3 位置作为源数据。如果你使用不同的 S3 位置，那么请记住替换参数中的路径（S3_DATA_FILE）：

1. 让我们编写一个COPY命令，如下面的代码块所示。我们将在load_data变量中创建COPY命令，使用 S3 路径作为参数：

   load_data = f"""COPY chapter2.orders
   

   FROM '{S3_DATA_FILE}'
   

   IAM_ROLE default
   

   FORMAT AS PARQUET;"""
   

2. 接下来，我们将使用execute_statement方法来运行这个COPY命令并捕获id语句：

   res = client.execute_statement(Database='dev', Sql=load_data,
   

                                 WorkgroupName=REDSHIFT WORKGROUP)
   

   query_id = res["Id"]
   

   print(query_id)
   

请确保检查查询的状态是否为FINISHED。

1. 一旦将状态定义为FINISHED，我们将通过运行一个计数查询来验证我们的数据加载，如下所示：

   cnt = client.execute_statement(Database='dev', Sql='Select count(1) from chapter2.orders ;', WorkgroupName=REDSHIFT_WORKGROUP)
   

   query_id = cnt["Id"]
   

我们现在将打印结果：

图 2.19 – 计数查询结果

正如你在图 2**.19中看到的，我们已经成功加载了 150 万行。

在笔记本中，我们提供了一个组合代码块，展示了如何将这些步骤转换成一个函数，并在需要时调用它来将数据加载到新表中。

我们还有一个 GitHub 仓库(github.com/aws-samples/getting-started-with-amazon-redshift-data-api/)，展示了如何在不同语言中开始使用 Amazon Redshift Data API，例如 Go、Java、JavaScript、Python 和 TypeScript。你可以通过仓库中解释的逐步过程，使用 Redshift Data API 在这些所有语言中构建你的自定义应用程序。

摘要

在本章中，我们展示了如何使用三种不同的工具和方法将数据加载到你的 Amazon Redshift Serverless 数据库中，通过使用查询编辑器 v GUI 界面，Redshift COPY命令来加载数据，以及使用 Python 在 Jupyter 笔记本中调用 Redshift Data API。所有三种方法都高效且易于使用，适用于你的不同用例。

我们还讨论了一些关于COPY命令的最佳实践，以使其更有效地使用。

在下一章中，我们将从关于 Amazon Redshift 机器学习的第一个主题开始，你将看到如何在你的 Amazon Redshift Serverless 数据仓库中利用它。

第三章：在您的数据仓库中应用机器学习

机器学习（ML）是当今现代商业世界中组织的一个常规和必要部分。机器学习的起源可以追溯到 20 世纪 40 年代，当时逻辑学家沃尔特·皮茨和神经科学家沃伦·麦克库洛赫试图创建一个能够描绘人类思维过程的神经网络。

组织可以利用他们的数据和机器学习算法来构建一个数学模型，以便做出更快、更明智的决定，而数据对组织今天的价值是无法低估的。数据量将继续快速增长，那些能够最有效地管理其数据进行预测分析和识别趋势的组织将拥有竞争优势、降低成本和增加收入。但为了真正释放这种能力，你必须将机器学习更接近数据，提供不需要深厚数据科学背景的自助工具，并消除不必要的数据处理，以加快将机器学习模型投入管道的时间。

本章将向您介绍机器学习，并讨论在您的数据仓库中应用机器学习的常见用例。您将开始看到可能的技艺，并想象如何通过使用 Amazon Redshift ML 更快、更轻松地实现业务成果。我们将引导您了解以下主题：

• 理解机器学习算法的基本知识

• 实施机器学习的传统步骤

• 克服实施机器学习的挑战

• 探索机器学习的益处

理解机器学习的基本知识

在本节中，我们将更详细地介绍机器学习，以便你对以下领域有一个一般性的了解：

• 监督学习与无监督学习

• 分类问题

• 回归问题

让我们从监督学习和无监督学习开始。

比较监督学习和无监督学习

监督学习算法由包含你想要预测的已知结果的数据进行监督。机器学习模型从这些已知结果中学习，然后使用这些学习来预测新数据的输出。

数据中的这个已知结果也被称为标签或目标。例如，如果你有一个包含房屋销售信息的数据集，销售价格通常会作为目标。

监督学习可以进一步细分为分类或回归问题。

在无监督学习中，机器学习模型必须通过根据相似性、差异和其他模式对数据进行分组来从数据结果中学习，而不需要任何指导或已知结果。

您可以使用无监督算法在数据中找到模式。例如，您可以使用无监督学习进行客户细分，以更有效地针对客户群体。其他用例包括以下：

• 检测异常传感器读数

• 文档标记

利用数据仓库中丰富的数据，你可以轻松开始使用监督学习和无监督学习来训练模型。

让我们深入了解分类和回归问题类型。

分类

分类问题是预测类别标签的任务，可以是二分类或多分类：

• 二分类 – 结果可以是两个可能类别中的一个，例如，预测客户是否会流失，一封电子邮件是否为垃圾邮件，或者感染 COVID-19 后患者是否可能住院。

• 多分类 – 结果可以是三个或更多可能类别中的一个 – 例如，预测植物物种或新闻文章属于哪个类别。其他多分类用例包括以下内容：

  • 销售预测

  • 智能呼叫路由

  • 广告优化

回归

当你有连续值的目标并希望根据输入变量预测一个值时，会使用回归问题。

回归问题是预测连续数值的任务：

• 线性回归：使用线性回归，我们可以预测一个数值结果，例如预测一个客户将花费多少或即将到来的音乐会或体育赛事的预测收入。有关更多详细信息，请参阅第七章，构建回归模型。

• 逻辑回归：逻辑回归是解决二分类问题的另一种选择。我们将在第六章，构建分类模型中展示一些该技术的示例。

回归用例示例包括以下内容：

• 价格和收入预测

• 客户终身价值预测

• 检测客户是否会违约贷款

现在我们将介绍实现机器学习的步骤。

实现机器学习的传统步骤

在本节中，你将更好地了解产生最佳机器学习模型所需的关键步骤：

• 数据准备

• 机器学习模型评估

数据准备

机器学习中的一个典型步骤是将原始数据转换为训练模型，以便数据科学家和数据分析师可以将机器学习算法应用于数据。你也可能听到数据清洗或特征工程这些术语。

此步骤是必要的，因为机器学习算法需要输入编号。例如，你可能需要从数据中移除异常值或异常。此外，你可能需要填补缺失的数据值，例如节假日缺失的记录。这有助于提高模型的准确性。

此外，确保你的训练数据集无偏见也很重要。机器学习模型从数据中学习，因此你的训练数据集需要有足够的代表性，以反映人口统计群体。

这里有一些数据准备步骤的示例：

• 确定模型所需的输入 - 这是识别对机器学习模型结果影响最大的属性的过程。

• 清理数据 - 纠正数据质量错误，消除重复行和异常数据。您需要调查数据并寻找异常值 - 这需要了解领域知识和业务逻辑的应用。

• 转换输入特征 - 机器模型需要输入为数值型。例如，当您有非有序数据（如国家或性别数据）时，您将使用一种称为独热编码的技术。这将把分类值转换为二进制值，从而创建更好的分类器，因此模型也更好。但如您稍后所见，当您使用 Redshift ML 的 Auto ML 功能时，这已经为您处理好了。

• num_class（用于多分类）和 XGBoost 模型中的轮数（num_rounds）。请注意，Amazon Redshift ML 会自动调整您的模型。

• 测试数据集 - 这是训练和调整模型后用于评估模型性能的剩余 10%的数据。

传统上，数据准备是一个非常耗时的步骤，也是机器学习复杂的一个原因。如您稍后所见，Amazon Redshift ML 自动化了许多数据准备步骤，以便您可以专注于创建模型。

评估机器学习模型

在您创建模型后，您需要计算模型的准确率。当使用 Amazon Redshift ML 时，您将获得一个量化模型准确率的指标。

这里有一些常用的确定模型准确率的方法：

• 均方误差（MSE）：MSE 是预测值与实际值之间平方差的平均值。它用于衡量回归模型的有效性。MSE 值始终为正：模型在预测实际值方面越好，MSE 值越小。当数据包含异常值时，它们往往会主导 MSE，这可能会造成预测性能不佳。

• 准确率：正确分类的项目数与总分类项目数（正确和错误分类）的比例。它用于二分类和多分类。它衡量预测类别值与实际值之间的接近程度。准确率值介于零和一之间：一表示完美准确，零表示完美不准确。

• F1 分数：F1 分数是精确率和召回率的调和平均数。它用于将二分类别（通常称为正类和负类）进行分类。当预测与实际（正确）类别匹配时，称为真预测；当不匹配时，称为假预测。精确率是所有正预测（包括假正例）中真正例的比例，它衡量了预测正类时的预测质量。

• F1_Macro – F1 宏分数将 F1 评分应用于多类分类。在这种情况下，您需要预测多个类别。您只需像在二元分类中对正类那样计算每个类的精确率和召回率。F1 宏分数介于零和一之间：一表示最佳性能，零表示最差。

• 曲线下面积（AUC）：AUC 指标用于比较和评估二元分类，例如逻辑回归等返回概率的算法。需要一个阈值将概率映射到分类。相关的曲线是接收者操作特征曲线，该曲线绘制了预测的真阳性率（TPR）或召回率与假阳性率（FPR）作为阈值值的函数，高于该阈值值，预测被认为是正的。

现在我们更详细地看看这些评估技术中的几个。

回归模型评估示例

回归模型的准确率由均方误差（MSE）和均方根误差（RMSE）来衡量。MSE 是模型数据集中预测值与实际值之间平均平方差的平均值，也称为真实值。您可以通过平方实际和预测答案之间的差异，然后取平均值来计算 MSE。MSE 的平方根计算 RMSE。低 MSE 和 RMSE 分数表明模型表现良好。

这里提供了一个简单的方法来计算均方误差（MSE）和均方根误差（RMSE），以便您可以将其与模型生成的 MSE 分数进行比较。假设我们有一个回归模型，预测客户下一个月的酒店预订数量。

按以下方式计算 MSE 和 RMSE：

MSE = (AVG(POWER(( actual_bookings - predicted_bookings)
RMSE = (SQRT(AVG(POWER(( actual_bookings  - predicted_bookings

您将在第七章中的一个练习中计算回归模型的 MSE 和 RMSE。

一个分类模型可以根据准确率进行评估。准确率方法相当直接，可以通过将预测总数与正确预测总数的百分比来衡量。

二元分类评估示例

混淆矩阵对于理解分类模型的性能非常有用，是评估分类模型的一种推荐方法。如果您想了解更多关于这个话题的信息，我们提供了以下详细信息。我们还在第十章中提供了一个详细的示例。

混淆矩阵以表格格式呈现，包含四个单元格 – 实际值构成x轴，预测值构成y轴，单元格表示真阳性、假阳性、假阴性和真阴性。这有助于衡量精确率、召回率和曲线下面积（AUC）。图 3.1显示了简单的混淆矩阵：

	实际值
	真阳性	假阳性
预测值	假阴性	真阴性

图 3.1 – 简单混淆矩阵

在图 3.2中，我们的数据集中有 100 条记录用于我们的二元分类模型，我们试图预测客户流失：

	实际值
	10	4
预测值	6	80

图 3.2 – 混淆矩阵

我们可以这样解释模型预测的质量：

• 正确预测了 10 个客户将会流失

• 正确预测了 80 个客户不会流失

• 错误地预测了 4 个客户将会流失

• 错误地预测了 6 个客户不会流失

F1 分数是最重要的评估指标之一，因为它考虑了模型的精确度和回收率。例如，F1 分数为.92意味着模型正确预测了 92%的时间。这种方法确保了对两个类别的预测都是好的，并且不是只偏向一个类别。

使用我们来自图 3.2的混淆矩阵示例，我们可以计算精确度：

精确度 = 10 / (10 + 4)

这也可以写成以下形式：

精确度 = 真阳性  _______________________   (真阳性 + 假阳性)

我们也可以以类似的方式计算回收率：

回收率 = 10 / (10 + 6)

这也可以写成以下形式：

回收率 = 真阳性  _______________________   (真阳性 + 假阴性)

F1 分数结合了精确度和回收率——它可以按以下方式计算：

2 × (精确度 × 回收率 / 精确度 + 回收率)

我们已经向您展示了评估机器学习模型的常用技术。随着我们继续阅读本书，您将看到可以应用于您机器学习评估流程的这些技术示例。

现在您已经学习了机器学习的基础知识，我们将讨论一些实施机器学习时常见的挑战以及如何克服这些挑战。

克服实施机器学习当前的挑战

数据增长既是机遇也是挑战，组织正在寻求从他们的数据中提取更多价值。业务线用户、数据分析师和开发者被要求使用这些数据来交付业务成果。这些用户需要易于使用的工具，通常不具备典型数据科学家的技能组合，也没有学习这些技能和成为数据管理专家的充裕时间。中央 IT 部门被分析和数据需求压得喘不过气来，正在寻找解决方案，以提供在易于使用的强大系统之上交付的自服务工具。以下是一些主要挑战：

• 数据更加多样化和快速增长。我们已经从分析千兆字节的数据发展到分析太字节和艾字节的数据。这些数据通常分布在组织中的许多不同的数据存储中。这意味着数据必须导出并转移到另一个平台以训练机器学习模型。Amazon Redshift ML 让您能够使用现有数据训练模型，而无需移动它。

• 数据管理方面的缺乏专业知识影响了有效扩展以跟上数据量和使用量增加的能力。

• 由于数据孤岛和训练模型以及使其可用于预测所需的时间，缺乏敏捷性来快速响应事件和客户升级。

• 缺乏合格的数据科学家来满足今天对机器学习的需求。需求是由改善客户体验、预测未来收入、检测欺诈和提供更好的患者护理等需求驱动的。

考虑以下创建 ML 模型的流程：

图 3.3 – 典型的机器学习工作流程

以下是在 图 3.3 中展示的创建 ML 模型的步骤：

1. 首先，我们从数据准备开始。这可能是一个非常耗时的过程，数据可能来自许多不同的来源。这些数据必须被清洗、整理，并分成训练集和测试集。然后，需要将其导出并加载到训练环境中。

2. 然后，您必须知道应该使用哪种 ML 算法，或者您需要训练您的模型。这需要一个熟练使用 R 或 Python 等工具的数据科学家，并具有了解特定问题哪种算法最佳的经验。正如您将在后面的章节中看到的那样，Amazon Redshift ML 可以自动为您确定算法。

3. 然后，您将通过训练、调整和验证模型多次迭代，直到找到最适合您用例的最佳模型。

4. 然后，在部署模型后，您需要持续监控模型的质量，并管理环境，包括扩展硬件以及根据需要应用补丁和升级。

为了减少构建机器学习数据管道所需的时间，我们必须将机器学习与数据更接近，并减少不必要的数据移动。您可以使用我们之前在第一章中讨论的数据架构，即以数据仓库为中心的架构。这还包括您的数据湖和其他操作数据存储，这些存储在一起，提供了一个统一视图，您的所有数据都组织有序，并以安全的方式轻松可用。

你可以基于你已构建的分析栈，并让你的数据分析师构建和训练他们自己的模型。所有数据仓库用户都可以在没有数据科学经验的情况下利用机器学习的力量。数据仓库用户可以使用熟悉的 SQL 命令创建、训练和部署机器学习模型。然后，使用 SQL，他们可以使用这些模型来分析来自 Amazon Redshift 的数据。你还可以利用你现有的 Amazon SageMaker 模型，并在 Amazon Redshift 的数据存储上进行推理。数据科学家可以利用 Redshift ML 通过直接通过 Redshift 基准模型来加速迭代。BI 专业人士现在可以直接通过工具如 Amazon QuickSight 运行推理查询。

一旦你在组织中实施机器学习，你将开始获得许多好处，我们将在下一节中进一步探讨。

探索机器学习的益处

商业在三个主要领域可以看到机器学习的益处：

• 增加收入 – 使用机器学习，你可以利用你的数据快速测试新想法，以改善客户体验。例如，使用无监督学习，你可以细分你的客户并发现以前未知的购买模式，这可以推动针对特定产品或订阅提供的针对性营销活动。

• 提高运营和财务效率 – 机器学习可以增加你业务中的自动化和敏捷性，以便你能更快地应对市场变化。一个例子是更准确地预测产品需求。通过更好地管理库存，组织可以看到巨大的成本节约。

• 提高应对业务风险的能力 – 使用机器学习，你可以比以前更快地做出决策。通过使用机器学习来检测异常，当你的供应链、产品质量和其他业务领域面临风险时，你可以迅速采取行动。

机器学习在数据仓库中的应用

让我们从高层次上看看几个用例，以说明一些这些益处。随后的章节将深入探讨细节：

• 提升客户体验：机器学习可以用来减少客户因长时间等待而产生的挫败感。聊天机器人可以快速回答许多客户问题，在某些情况下，甚至可以回答他们所有的问题：

  • 个性化：机器学习可以用来更好地理解客户的行为和购买历史，以便根据他们的兴趣向客户提供更相关的产品。

  • 情感分析：机器学习可以用来理解来自社交媒体平台的客户情绪。这种分析可以用于营销活动和客户保留工作。

• 预测设备维护：考虑任何拥有车队或设备的公司。这可能是一家包裹递送公司或必须适当维护的服务提供商公司。没有机器学习，设备可能被过早或过于频繁地维修，这会导致更高的成本，或者设备可能被过晚维修，导致设备无法使用。

您可以使用机器学习来预测每辆车或设备需要维护的最佳时间，以最大化运营效率。

• 金融分析：银行和投资公司使用机器学习进行自动化、风险评估、投资组合分配等等：

  • 计算信用评分 – 机器学习可以快速计算信用评分并批准贷款，从而降低风险。

  • 欺诈检测 – 机器学习可以快速扫描大量数据集以检测异常，标记交易并自动拒绝或批准交易。根据交易的性质，系统可以自动拒绝提款或购买，直到人类做出决定。

• 体育产业：赛车队可以使用模型来预测成功的最佳策略和最有效的维修站策略：

  • 通过预测未来表现来构建更强大的团队阵容

  • 通过预测未来伤害来提高球员安全

• 医疗保健行业：通过结合机器学习与历史患者和治疗记录，以及预测成功率最高的治疗方案来早期检测健康状况。

这些只是机器学习的一些益处。可能性是无限的，而且进步正在不断进行。随着我们进入后续章节，您将看到一些实际的应用案例，您可以在自己的环境中尝试，并开始构建您的机器学习技能集。

摘要

在本章中，我们向您介绍了如何将机器学习应用于数据仓库，并解释了机器学习的基本概念。我们还讨论了如何克服实施机器学习所面临的挑战，以便您能在组织中享受到机器学习的益处。

这些益处有助于增加收入、提高运营效率以及更好地应对不断变化的企业环境。在本章之后，您现在对在数据仓库中可以部署的使用案例和模型类型有了基础的了解。

在下一章中，我们将向您介绍 Amazon Redshift ML 以及如何开始实现业务成果。

第二部分：开始使用 Redshift ML

第二部分从 Amazon Redshift ML 的概述开始，然后深入探讨如何使用 Amazon Redshift ML 创建各种机器学习模型。

在第二部分结束时，您将了解如何通过简单地运行 SQL 命令来创建模型，了解监督学习和无监督学习之间的区别，以及如何解决分类、回归和聚类问题。

本部分包括以下章节：

• 第四章，利用 Amazon Redshift 机器学习

• 第五章，构建您的第一个机器学习模型

• 第六章，构建分类模型

• 第七章，构建回归模型

• 第八章，使用 K-Means 聚类构建无监督模型

第四章：利用 Amazon Redshift ML

在上一章中，我们讨论了机器学习（ML）的整体优势以及它如何融入您的数据仓库。

在本章中，我们将专门探讨如何利用Amazon Redshift ML来解决各种用例。这些示例旨在为您在从第五章开始的实际训练模型过程中提供所需的基础。我们将展示 Redshift ML 的优势，例如消除数据移动、能够使用简单的 SQL 创建模型，以及大幅减少训练新模型和使其可用于推理所需的时间。此外，您还将了解 Amazon Redshift ML 如何通过以下主要主题在幕后利用Amazon SageMaker自动训练您的模型：

• 为什么选择 Amazon Redshift ML？

• Amazon Redshift ML 简介

• 创建模型概述

为什么选择 Amazon Redshift ML？

Amazon Redshift ML 让您能够通过简单的 SQL 命令创建和训练 ML 模型，无需构建专门的技能。这意味着您的数据分析师、数据工程师和 BI 分析师现在可以利用他们的 SQL 技能进行 ML，这增加了敏捷性，因为他们不再需要等待 ML 专家来训练他们的模型。

此外，由于您在数据仓库中使用模型，您不再需要将数据导出用于训练，或者在使用模型进行预测后将数据导入仓库。

您无需担心数据治理的管理。当您导出数据用于训练时，数据永远不会离开您的 VPC。

您可以控制谁可以创建模型以及谁可以在这些模型上运行推理查询。

Amazon Redshift ML 为训练和使用模型提供了一个非常经济高效的解决方案。Amazon SageMaker 资源的成本基于您的训练数据集中的单元格数，这是训练集行数和列数的乘积。

使用 Amazon Redshift Serverless 运行预测查询的成本基于您的查询使用的计算能力。

要了解更多关于 Amazon Redshift Serverless 成本的信息，请参阅此处docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html。

您可以通过限制用于训练模型的数据量以及控制训练时间来控制模型训练的成本。我们将在创建模型概述部分稍后展示这一示例。

当您运行预测查询时，所有预测都在您的 Redshift 数据仓库中本地计算。这使得您能够实现非常高的吞吐量和低延迟。

Amazon Redshift ML 简介

通过利用 Amazon Redshift ML，你的组织可以实现许多好处。首先，你可以消除不必要的数据移动，用户可以使用熟悉的 SQL 命令，并且与 Amazon SageMaker 的集成是透明的。

让我们定义一些你将在剩余章节中看到的术语：

• 创建模型：这是一个将包含用于将数据导出以用于训练你的模型的 SQL 命令的命令。

• 特征：这些是在你的数据集中用作训练模型输入的属性。

• 目标：这是你数据集中你想要预测的属性。这有时也被称为标签。

• 推理：这也被称为预测。在 Amazon Redshift ML 中，这是执行查询以获取由你的模型生成的预测值的流程。

为了能够创建和访问你的 ML 模型在 Amazon Redshift 中运行预测查询，你需要对模型对象授予权限，就像你在其他数据库对象（如表、视图或函数）上所做的那样。

假设你已经创建了一个名为analyst_cm_role的角色，允许一组用户创建模型。超级用户可以按照以下方式授予此角色的权限：

GRANT CREATE MODEL to role analyst_cm_role

拥有CREATE MODEL权限的用户/组/角色可以在你的服务器端点或 Redshift 集群中的任何模式中创建模型，如果用户有该模式的CREATE权限。Redshift ML 模型是模式层次结构的一部分，类似于表、视图、存储过程和用户定义的函数。假设我们有一个名为demo_ml的模式。你可以使用以下GRANT语句授予demo_ml模式上的CREATE和USAGE权限给分析师角色：

GRANT CREATE, USAGE ON SCHEMA demo_ml TO role analyst_cm_role

现在，假设我们有一个名为analyst_prediction_role的角色，允许一组用户运行预测查询。你可以使用以下方式授予在模型上运行预测的访问权限：

GRANT EXECUTE ON MODEL demo_ml.customer_churn_auto_model TO role analyts_prediction_role

创建模型的数据源可以是 Redshift 或任何其他你可以从 Redshift 访问的源，包括通过 Spectrum 或其他使用 Redshift 联合查询功能的源访问的Amazon Simple Storage Service（Amazon S3）S3 数据湖。在撰写本文时，支持 Amazon Aurora 和 Amazon RDS for PostgreSQL 和 MySQL。更多详细信息请参阅docs.aws.amazon.com/redshift/latest/dg/federated-overview.html。

Amazon Redshift ML 和 Amazon SageMaker 管理所有数据转换、权限和资源使用。然后，由 SageMaker Neo 编译训练好的模型，并在 Amazon Redshift 中以用户定义的函数的形式提供，以便用户可以使用简单的 SQL 进行预测。

一旦你的模型经过训练并作为 Amazon Redshift 中的函数可用，你就可以大规模和高效地运行预测查询，本地在 Amazon Redshift 中。

请参见图 4.1 中的流程图：

图 4.1 – Redshift ML 创建模型流程

现在，让我们更详细地介绍如何使用CREATE MODEL语句。

创建模型的概述

CREATE MODEL语句在处理您可能需要的各种用例时提供了灵活性。主要有四种类型的CREATE MODEL语句：

• 自动化一切

• AUTO与用户指导，用户可以提供问题类型

• AUTO OFF，用户提供了定制选项

• 自带 模型 (BYOM)

图 4**.2展示了使用 Amazon Redshift ML 训练模型时的灵活性：

图 4.2 – Amazon Redshift ML 的灵活性

在本章中，我们将概述各种类型的CREATE MODEL语句。后续章节将提供如何创建所有不同类型模型的深入示例，如何将数据加载到 Redshift，以及如何将您的数据分割成训练集和测试集。

在本节中，我们将向您介绍创建模型时可用的选项以及您可以指定的可选参数。本章中的所有示例都是信息性的，旨在为您准备后续章节。您将在第五章中创建您的第一个模型。

自动化一切

当您执行CREATE MODEL命令以使用AUTO一切来解决监督学习问题时，Amazon Redshift ML 和 Amazon SageMaker 将为您管理所有数据预处理、模型训练和模型调优。数据将从 Amazon Redshift 导出到 Amazon S3，在那里 SageMaker 将训练和调整多达 100 个模型。SageMaker Autopilot将自动确定算法和问题类型。然后，最佳训练模型将由 SageMaker Neo 编译，并在 Amazon Redshift 中作为用户定义的函数提供，以便用户可以使用简单的 SQL 进行预测。

以下是一个AUTO一切模型语法的示例：

CREATE MODEL model_name
    FROM { table_name | ( select_query ) }
    TARGET column_name
    FUNCTION prediction_function_name
    IAM_ROLE { default }
    SETTINGS (
      S3_BUCKET 'bucket',
      [ MAX_CELLS integer ]
    )

您只需提供要用于训练的数据的表名或 SQL 语句，以及您试图预测的TARGET列。

让我们用一个简单的例子来应用这个方法。假设我们有一个名为reservation_history的表，其中包含酒店预订数据，我们想要确定客人是否有可能取消即将到来的预订：

CREATE TABLE reservation_history (
customerid bigint ,
city character varying(50),
reservation_date timestamp without time zone,
loyalty_program character (1),
age bigint,
marital_status character (1),
cancelled character (1)
)
DISTSTYLE AUTO;

CREATE MODEL语句将看起来像这样（请注意，这仅用于信息；您不需要运行此命令）：

CREATE MODEL predict_guest_cancellation
    FROM reservation_history
    TARGET cancelled
    FUNCTION predict_cancelled_reservation
    IAM_ROLE default
    SETTINGS (
      S3_BUCKET '<<your-s3-bucket>>'
)

在这个CREATE MODEL语句中，我们只提供了所需的最小参数，即IAM_ROLE和S3_BUCKET。TARGET参数被标记为cancelled，这是我们根据发送给CREATE MODEL语句的输入尝试预测的内容。在这个例子中，我们发送了reservation_history表中的所有内容。FUNCTION名称是描述将用于后续预测的函数的描述。IAM_ROLE参数将附加到您的无服务器端点，并提供对 SageMaker 和CREATE MODEL语句的访问。请参阅第二章，其中我们展示了如何设置 IAM 角色。

Amazon SageMaker 将自动确定这是一个二元分类模型，因为我们的TARGET只能有两个可能的值。Amazon SageMaker 还将选择最佳模型类型。在撰写本文时，支持监督学习的模型类型如下：

• XGBoost：基于梯度提升树算法

• Linear Learner：提供提高解决分类或回归问题速度的能力

• MLP：使用多层感知器的深度学习算法

您将在后续章节中使用这些模型中的每一个来创建模型。

自动加用户指导

对于对机器学习有良好理解的更高级用户，可能希望向模型提供更多输入，例如model_type、problem_type、preprocessors和objective。

使用我们的预订示例，我们将利用AUTO功能并指定一些额外的参数：

• MODEL_TYPE: XGBoost

• PROBLEM_TYPE: binary_classification

• Objective: F1

• S3_GARBAGE_COLLECT – OFF：如果设置为OFF，用于训练模型的生成的数据集将保留在 Amazon S3 中，并可被用于其他目的，例如故障排除

• MAX_RUNTIME – 1800：这是通过将训练时间限制为1800秒来控制模型训练成本的一种方式；默认值为5400秒

通过指定MODEL_TYPE和/或PROBLEM_TYPE以及Objective参数，您可以缩短训练模型所需的时间，因为 SageMaker 不需要确定这些参数。以下是一个CREATE MODEL语句的示例：

CREATE MODEL predict_guest_cancellation
    FROM reservation_history
    TARGET cancelled
    FUNCTION predict_cancelled_reservation
    IAM_ROLE default
    MODEL_TYPE XGBoost
    PROBLEM_TYPE BINARY CLASSIFICATION
    OBJECTIVE 'F1'
    SETTINGS (
      S3_BUCKET '<<your-S3-bucket>>',
      MAX_RUNTIME 1800
);

注意

增加最大运行时间MAX_RUNTIME和最大单元格数MAX_CELLS通常可以通过让 SageMaker 探索更多候选者来提高模型质量。如果您希望加快数据集的迭代或探索速度，请减少MAX_RUNTIME和MAX_CELLS。如果您希望提高模型的准确性，请增加MAX_RUNTIME和MAX_CELLS。

如果已知，指定问题类型和目标是一个好习惯，可以缩短训练时间。为了提高模型准确性，如果可能的话，提供更多数据，并包括任何可能影响目标变量的特征（输入）。

此外，您可以通过指定转换器来添加自己的预处理器。截至编写本文时，Amazon Redshift ML 支持 10 个转换器，包括 OneHotEncoder、Ordinal Encoder 和 StandardScaler。您可以在以下位置找到完整的列表：docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_user_guidance_create_model。

Amazon Redshift ML 存储训练好的转换器，并将其作为预测查询的一部分自动应用。在从您的模型生成预测时，您无需指定它们。

以 OneHotEncoder 为例，它用于将诸如 country 或 gender 这样的分类值转换为数值（二进制向量），以便机器学习算法可以更好地进行预测。让我们创建一个模型，使用独热编码对输入列 marital_status 和 loyalty_program 进行编码。请注意，此模型仅作为示例，您无需运行此语句：

 CREATE MODEL predict_guest_cancellation
    FROM reservation_history
    TARGET cancelled
    FUNCTION predict_cancelled_reservation
    IAM_ROLE default
    MODEL_TYPE XGBoost
    PROBLEM_TYPE BINARY CLASSIFICATION
    OBJECTIVE 'F1'
    PREPROCESSORS '[
      {"ColumnSet": [
        "loyalty_program",
        "marital_status"
        ],
        "Transformers" :[
           "OneHotEncoder"
            ]
         ]
        }
     ]'
    SETTINGS (
      S3_BUCKET '<<your-S3-bucket>>',
      MAX_RUNTIME 1800
);

到目前为止，我们展示的所有 CREATE MODEL 示例都使用了 AUTO ON。如果您未指定此参数，则这是默认设置。现在，让我们继续了解如何使用 AUTO OFF 和 XGBoost 进行自己的模型调整。

XGBoost (AUTO OFF)

作为一名机器学习专家，您有使用 CREATE MODEL 语句的 AUTO OFF 选项进行超参数调整的选项。这使您拥有完全控制权，Amazon Redshift ML 不会尝试发现最佳预处理器、算法和超参数。

让我们看看使用我们的示例预订数据集的 CREATE MODEL 语法是什么样的。

我们将指定以下参数：

• AUTO OFF：关闭自动发现预处理器、算法和超参数

• MODEL_TYPE:- xgboost

• OBJECTIVE: 'binary:logistic'

• PREPROCESSORS: 'none'

• HYPERPARAMETERS: DEFAULT EXCEPT(NUM_ROUND '100'/)

请参考以下链接以获取 XGBoost 的超参数列表：docs.amazonaws.cn/en_us/redshift/latest/dg/。

r_create_model_use_cases.html#r_auto_off_create_model

就本文所述，'none' 是使用 AUTO OFF 时为 PREPROCESSORS 指定的唯一可用选项。由于我们无法指定独热编码，我们可以使用 SQL 中的 case 语句来应用此选项：

CREATE MODEL predict guest_cancellation
    FROM
        (Select customerid,
       city,
       reservation_date,
       case when loyalty_program = 'Y' then 1 else 0 end as loyalty_program_y,
       case when loyalty_program = 'N' then 1 else 0 end as loyalty_program_n,
       age,
       case when marital_status = 'Y' then 1 else 0 end as married,
       case when marital_status = 'N' then 1 else 0 end as not_married,
       cancelled
       from reservation_hitory)
    TARGET cancelled
    FUNCTION predict_cancelled_reservation
    IAM_ROLE default
    AUTO OFF
    MODEL_TYPE XGBoost
    OBJECTIVE 'binary:logistic'
    PREPROCESSORS 'none'
    HYPERPARAMETERS DEFAULT EXCEPT (NUM_ROUND '100')
    SETTINGS (
      S3_BUCKET 'bucket',
      MAX_RUNTIME 1800
);

在 第十章 中，您将使用 AUTO OFF 构建 XGBoost 模型，并更好地理解此选项。

现在，让我们看看使用 K-means 算法的另一个 AUTO OFF 选项。

K-means (AUTO OFF)

K-means 算法用于将未标记的数据分组在一起。由于此算法在您的数据中发现了分组，因此它解决了一个“无监督”学习问题。

如果我们想要对 reservation_history 数据进行分组，让我们看看一个示例 CREATE MODEL 是什么样的：

• AUTO OFF：关闭自动发现预处理器、算法和超参数

• MODEL_TYPE: KMEANS

• PREPROCESSORS: OPTIONAL（在撰写本文时，Amazon Redshift 支持 StandScaler、MinMax 和 NumericPassthrough 用于 KMEANS）

• HYPERPARAMETERS: DEFAULT EXCEPT (K 'N')，其中 N 是您想要创建的集群数量

这里是一个 CREATE MODE``L 语句的示例。请注意，您不会运行此语句：

CREATE MODEL guest_clusters
    FROM
        (Select
        city,
        reservation_date,
        loyalty_program,
        age,
        marital_status
        from reservation_hitory)
    FUNCTION get_guest_clusters
    IAM_ROLE default
    AUTO OFF
    MODEL_TYPE KMEANS
    PREPROCESSORS 'none'
    HYPERPARAMETERS DEFAULT
    EXCEPT (K '5')
    SETTINGS (
      S3_BUCKET '<<your-S3-bucket>>'
);

注意，我们使用此模型创建了五个集群。在使用 K-means 算法时，尝试不同的集群数量很重要。在 第八章 中，您将深入了解创建 K-means 模型以及如何验证最佳集群。

现在，让我们看看如何使用在 Amazon Redshift ML 之外构建的模型运行预测查询。

BYOM

此外，您还可以使用在 Amazon Redshift 之外训练的模型，通过 Amazon SageMaker 在 Amazon Redshift 中进行本地或远程推理。

本地推理

当模型在 Amazon SageMaker 之外训练时，使用本地推理。这允许您在 Amazon Redshift 内运行推理查询，而无需重新训练模型。

假设我们之前的示例是构建一个用于预测客户是否会取消预订的模型，该模型是在 Amazon Redshift 之外训练的。我们可以将该模型带到 Redshift，然后运行推理查询。

我们的 CREATE MODEL 示例将如下所示：

• model_name: 这是您希望在 Redshift 中为本地模型指定的名称

• FROM: 这是来自 Amazon SageMaker 的 job_name – 您可以在 Amazon SageMaker 下的 训练作业 中找到它

• FUNCTION: 要创建的函数的名称以及输入数据类型

• RETURNS: 函数返回值的类型：

  CREATE MODEL predict_guest_cancellation_local_inf
  

      FROM 'sagemaker_job_name'
  

      FUNCTION predict_cancelled_reservation_local(bigint, varchar, timestamp, char, bigint, char)
  

      RETURNS char
  

      IAM_ROLE default
  

      SETTINGS (
  

        S3_BUCKET '<<your-S3-bucket>>' );
  

注意，FUNCTION 中的数据类型与我们的 reservation_history 表中的数据类型匹配，而 RETURNS 与我们的 TARGET 变量的数据类型匹配，该变量为 cancelled。

您可以通过访问 AWS 管理控制台并进入 SageMaker 来获取 SageMaker 的 JobName：

图 4.3 – 控制台首页

点击 Amazon SageMaker 后，点击 训练作业，如图 图 4**.4 所示：

图 4.4 – 训练作业

接下来，请注意您希望用于本地推理的模型的工作名称，这就是您将在 CREATE MODEL 语句中放入的内容（见 图 4**.5）：

图 4.5 – 训练作业名称

远程推理

如果您在 SageMaker 中创建了一个算法模型，而该算法在 Amazon Redshift ML 中不可用，则远程推理很有用。例如，可以使用 SageMaker 中的随机切割森林算法进行异常检测。您可以创建一个引用 SageMaker 模型端点的模型，然后在 Amazon Redshift 中运行异常检测。

我们的 CREATE MODEL 示例将如下所示：

• model_name: 你希望在 Redshift 中为本地模型提供的名称

• FUNCTION: 要创建的函数名称以及输入数据类型

• RETURNS: 函数返回值的类型

• SAGEMAKER: Amazon SageMaker 端点的名称：

CREATE MODEL random_cut_forest
FUNCTION remote_fn_rcf(int)
RETURNS decimal(10,6)
SAGEMAKER 'sagemaker_endpoint'
IAM_ROLE  default;

注意，FUNCTION 中的数据类型是我们发送的输入类型，而 RETURNS 是调用函数时接收到的数据类型。

你可以通过导航到 AWS 管理控制台，转到 SageMaker，然后点击 端点 来获取 SageMaker 端点：

图 4.6 – 端点

在点击 端点 后，如图 图 4**.6 所示，你可以看到端点名称，如图 图 4**.7 所示：

图 4.7 – 端点名称

然后，注意你希望用于远程推理的模型端点名称，并将其放入你的 CREATE MODEL 语句中。

你将在 第十一章 中深入了解 BYOM，并获得创建用于本地和远程推理的模型的实践经验。

摘要

在本章中，我们讨论了为什么 Amazon Redshift ML 是在数据仓库中使用数据进行预测的好选择。

通过将机器学习（ML）引入你的数据仓库，Amazon Redshift ML 使你能够通过将 ML 的力量直接交到你的开发者、数据分析师和 BI 专业人员手中，大大缩短创建和训练模型所需的时间。

你的数据保持安全；它永远不会离开你的 VPC。此外，你可以轻松控制对创建和使用模型的访问。

最后，我们向你展示了在 Redshift ML 中创建模型的不同方法，例如使用 AUTO，如何指导模型训练，以及提供超参数的高级方法。

现在，你了解了机器学习如何融入你的数据仓库，如何使用 Redshift ML 的适当安全性和配置指南，以及如何在 Amazon SageMaker 中训练模型。

在下一章中，你将亲自动手，使用 Amazon Redshift ML 创建你的第一个模型，学习如何验证模型，以及如何运行推理查询。

第五章：构建您的第一个机器学习模型

在上一章中，您学习了Redshift 机器学习（ML）的好处，例如消除数据移动，以及如何使用简单的结构化查询语言（SQL）命令创建模型。

在本章中，您将使用标准 SQL 方言构建您的第一个机器学习模型。Amazon Redshift 使得使用熟悉的 SQL 方言来训练、部署和运行机器学习模型变得非常容易。这种方法使得不同的数据角色，例如，数据库开发者、数据库工程师和公民数据科学家，能够在不将数据移出他们的数据仓库平台的情况下，并且无需学习新的编程语言的情况下，训练和构建机器学习模型变得容易。

在本章中，您将了解使用 Amazon Redshift ML 简单 CREATE MODEL，它使用CREATE MODEL命令和用于评估您的 ML 模型的不同方法。

在本章中，为了构建您的第一个机器学习模型，我们将探讨以下主要主题：

• Redshift ML 简单 CREATE MODEL

• 评估模型性能

技术要求

本章需要网络浏览器和以下内容：

• 一个 AWS 账户。

• 一个 Amazon Redshift Serverless 端点。

• Amazon Redshift 查询编辑器 v2。

• 完成在第一章中的“Amazon Redshift Serverless 入门”部分。

您可以在此处找到本章中使用的代码：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/

)

本章所需的数据文件位于公共 S3 存储桶中：s3://packt-serverless-ml-redshift/

)

让我们开始吧！

Redshift ML 简单 CREATE MODEL

Redshift ML 简单 CREATE MODEL 是 Amazon Redshift 中的一个功能，允许用户使用 SQL 命令创建机器学习模型，无需专业技能或软件。它通过允许用户使用熟悉的 SQL 语法来定义模型结构和输入数据，然后自动生成并使用 Amazon SageMaker 训练模型，从而简化了创建和部署机器学习模型的过程。此功能可用于各种机器学习任务，包括回归、分类和聚类。

在我们深入构建第一个 ML 模型之前，让我们通过定义一个将构成我们模型构建解决方案基础的问题陈述来设定场景。

我们将使用客户销售数据集来构建第一个机器学习模型。虚构的ABC 公司的商务领导正面临着销售下降的问题。ABC 公司的数据团队已执行描述性和诊断分析，并确定销售下降的原因是客户流失。为了解决这个问题，熟悉 SQL 语言和一些机器学习概念的数据分析师利用了 Redshift ML。商务用户记录了哪些客户已经流失和未流失，并与数据分析师团队合作。

为了解决业务问题，数据分析师首先分析销售数据集。他们将通过 Redshift SQL 命令编写 SQL 聚合查询并创建可视化来了解趋势。然后，数据分析师团队使用 Redshift ML 的简单CREATE MODEL命令创建机器学习模型。最后，数据分析师评估模型性能以确保模型有用。

上传和分析数据

本章节所使用的数据集位于此处：s3://packt-serverless-ml-redshift/。我们已修改数据集以更好地满足章节要求。

数据集引用

此数据集归功于加州大学欧文分校机器学习数据集存储库（Jafari-Marandi, R., Denton, J., Idris, A., Smith, B. K., & Keramati, A. (2020). Optimum Profit-Driven Churn Decision Making: Innovative Artificial Neural Networks in Telecom Industry. Neural Computing and Applications）。

此数据集包含客户流失信息。以下表格列出了数据集的元数据：

名称	数据类型	定义
state	varchar(2)	客户所在的美国州
account_length	int	客户账户长度
area_code	int	客户的地区代码或邮政编码
phone	varchar(8)	客户的电话号码
intl_plan	varchar(3)	国际计划订阅者
vMail_plan	varchar(3)	语音邮件计划订阅者
vMail_message	int	语音邮件消息订阅者
day_mins	float	每日累计分钟数
day_calls	int	每日累计通话次数
day_charge	float	每日累计费用
total_charge	float	总费用
eve_mins	float	晚间分钟数
eve_calls	int	晚间通话次数
eve_charge	float	晚间费用
night_mins	float	夜间分钟数
night_calls	int	夜间通话次数
night_charge	float	夜间费用
intl_mins	float	国际分钟数
intl_calls	int	国际通话次数
intl_charge	float	国际费用
cust_serv_calls	int	客户服务通话次数
churn	varchar(6)	客户是否流失
record_date	date	记录更新日期

表 5.1 – 客户通话数据

在成功连接到 Redshift 作为管理员或数据库开发者后，创建架构并将数据加载到 Amazon Redshift 中，如下所示：

1. 导航到 Redshift 查询编辑器 v2，连接到 Serverless:default 端点，并连接到 dev 数据库。

创建一个新的编辑器，并将未命名的查询编辑器保存为 Chapter5，如图 图 5**.1 所示：

图 5.1 – 连接到查询编辑器 v2

1. 创建一个名为 Chapter5_buildfirstmodel 的 Redshift 架构。Redshift 架构包含表、视图和其他命名对象。对于本章，将在该架构中创建表和机器学习模型：

   Create schema chapter5_buildfirstmodel;
   

2. 创建一个名为 customer_calls_fact 的 Redshift 表。此表用于加载包含客户通话信息的数据集。此表在 Redshift 中原生创建，用于训练和验证 Redshift ML 模型：

   CREATE TABLE IF NOT EXISTS chapter5_buildfirstmodel.customer_calls_fact (
   

   state varchar(2),
   

   account_length int,
   

   area_code int,
   

   phone varchar(8),
   

   intl_plan varchar(3),
   

   vMail_plan varchar(3),
   

   vMail_message int,
   

   day_mins float,
   

   day_calls int,
   

   day_charge float,
   

   total_charge float,
   

   eve_mins float,
   

   eve_calls int,
   

   eve_charge float,
   

   night_mins float,
   

   night_calls int,
   

   night_charge float,
   

   intl_mins float,
   

   intl_calls int,
   

   intl_charge float,
   

   cust_serv_calls int,
   

   churn varchar(6),
   

   record_date date)
   

   Diststyle AUTO;
   

3. 使用以下命令将客户通话数据加载到 Redshift 表中：

           COPY  chapter5_buildfirstmodel.customer_calls_fact
   

   FROM 's3://packt-serverless-ml-redshift/chapter05/customerdime/'
   

   IAM_ROLE default
   

   delimiter ',' IGNOREHEADER 1
   

   region 'eu-west-1';
   

我们使用 Redshift COPY 命令将数据加载到我们的表中。COPY 命令将数据并行加载到 Redshift 表中。你可以使用 COPY 命令加载数以千计的数据。

1. 在最后一步，我们将通过创建客户流失直方图来分析客户流失事实表。为此，让我们使用查询编辑器 v2 图表功能来创建直方图图表。为了创建直方图，我们需要统计流失和未流失的客户数量。要获取这些信息，首先，运行以下命令：

   SELECT churn, count(*) Customer_Count FROM chapter5_buildfirstmodel.customer_calls_fact
   

   GROUP BY churn
   

   ;
   

现在，点击 结果 窗格右侧的 图表 选项，以查看直方图：

图 5.2 – 流失客户与未流失客户直方图

从前面的图表中，你可以看到 customer_calls_fact 表有 3333 名客户，其中 483 名已经流失。

现在，我们已经分析了数据集，并发现有一些客户已经流失。下一步是创建一个机器学习模型。为此，我们将使用 Redshift ML 简单的 CREATE MODEL 方法。

深入探讨 Redshift ML CREATE MODEL 语法

由于这是你第一次使用 CREATE MODEL 语法，让我们在这里刷新一下命令的基本结构。

Redshift ML 提供了易于使用的 CREATE MODEL 语法来创建机器学习模型。在本节中，我们将重点介绍 CREATE MODEL 命令的简单形式。在后面的章节中，你将学习到其他形式的创建模型语句。

简单 CREATE MODEL 是 Redshift CREATE MODEL 语句的最基本形式。它面向尚未准备好处理机器学习过程所有复杂性的用户。这种模型创建形式也由经验丰富的用户，如公民数据科学家，用于其创建机器学习模型的简单性。数据清洗是任何机器学习问题的一个基本步骤，否则，它遵循“垃圾输入，垃圾输出”的原则。然而，数据清洗仍然是必要的任务，但在 Redshift ML 数据转换、标准化和模型选择将不再必要。

我们使用以下命令进行简单模型创建：

CREATE MODEL model_name
    FROM { table_name | ( select_query ) }
    TARGET column_name
    FUNCTION prediction_function_name
    IAM_ROLE { default }
    SETTINGS (
      S3_BUCKET 'bucket',
      [ MAX_CELLS integer ]
    )

在前面的 CREATE MODEL 语法中，作为用户，你指定你的数据集 – 在我们的案例中，customer_calls_fact – 在 FROM 子句中。我们将我们想要预测的目标变量设置为 churn，在 TARGET 参数中。作为用户，你还需要为该函数命名，你将在选择查询中运行预测时使用该函数。

更多关于简单 CREATE MODEL 参数的信息，请参阅以下 Redshift 公共文档：[docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model

)

我们已经了解了通用的简单 CREATE MODEL 语法。现在，让我们为我们的数据集创建语法并运行它。

创建你的第一个机器学习模型

最后，我们将构建我们的第一个机器学习模型来预测客户流失事件。由于这是我们第一个机器学习模型，让我们使用简单的 CREATE MODEL 命令。此选项使用 Amazon SageMaker Autopilot，这意味着，无需进行构建机器学习模型的繁重工作，你只需提供一个表格数据集并选择要预测的目标列，SageMaker Autopilot 将自动探索不同的解决方案以找到最佳模型。这包括数据预处理、模型训练、模型选择和部署。AutoMode 是默认模式：

1. Redshift ML 通过 S3 存储桶在 Amazon Redshift 和 SageMaker 之间共享训练数据和工件。如果你还没有，你需要创建一个 S3 存储桶。为此，导航到 Amazon S3 控制台并点击 创建 存储桶 按钮：

图 5.3 – S3 控制台

1. 在 serverlessmachinelearningwithredshift-<your account id> 上，其中 <your account id> 是你的 AWS 账号。

图 5.4 – 创建 S3 存储桶

1. 在我们将数据集发送到 CREATE MODEL 命令之前，我们将数据集分成两部分——一部分是训练数据集，用于训练机器学习模型，另一部分是在模型创建后用于测试模型。我们通过过滤 record_date 小于 '2020-08-01' 的客户记录进行训练，以及 record_date 大于 '2020-07-31' 的记录进行测试。运行以下查询以检查我们的记录拆分：

   select sum(case when record_date <'2020-08-01' then 1 else 0 end) as Training_Data_Set,
   

   sum(case when record_date >'2020-07-31' then 1 else 0 end) as Test_Data_Set
   

   from chapter5_buildfirstmodel.customer_calls_fact
   

在 图 5.5 中，我们可以看到训练集中有 2714 条记录，测试集中有 619 条记录。

图 5.5 – 训练和测试数据集记录数

我们在训练和测试我们的数据集时应用过滤条件。在下一步中，我们将使用数据集上的这个过滤条件来创建模型。

1. 现在运行以下代码以创建 customer_churn_model。请确保将 <your account id> 替换为正确的 AWS 账号。请注意，由于我们将使用简单的 CREATE MODEL，我们通过 MAX_RUNTIME 参数设置了最大允许时间。这是 Autopilot 将花费的最大训练时间。我们将其设置为 1,800 秒，即 30 分钟。如果您未指定 MAX_RUNTIME 的值，它将使用默认值 5,400 秒（90 分钟）：

   CREATE MODEL chapter5_buildfirstmodel.customer_churn_model
   

   FROM (SELECT state,
   

                 account_length,
   

                 area_code,
   

                 phone,
   

                 intl_plan,
   

                 vMail_plan,
   

                 vMail_message,
   

                 day_mins,
   

                 day_calls,
   

                 day_charge,
   

                 total_charge,
   

                 eve_mins,
   

                 eve_calls,
   

                 eve_charge,
   

                 night_mins,
   

                 night_calls,
   

                 night_charge,
   

                 intl_mins,
   

                 intl_calls,
   

                 intl_charge,
   

                 cust_serv_calls,
   

                replace(churn,'.','') as churn
   

         FROM chapter5_buildfirstmodel.customer_calls_fact
   

            WHERE record_date < '2020-08-01'
   

        )
   

   TARGET churn
   

   FUNCTION predict_customer_churn
   

   IAM_ROLE default
   

   SETTINGS (
   

     S3_BUCKET 'serverlessmachinelearningwithredshift-<your account id>',
   

     MAX_RUNTIME 1800
   

   )
   

   ;
   

让我们更深入地了解前面的命令：

• FROM 子句中的 SELECT 查询指定了训练数据

• TARGET 子句指定了 CREATE MODEL 语句构建模型以预测的标签所在的列

• 训练查询中的其他列是用于预测流失变量的特征（输入）

• predict_customer_churn 函数是在 SELECT 查询中使用的推理函数的名称，用于生成预测

• S3_Bucket 是 Redshift ML 在与 SageMaker 一起工作时保存工件的位置

• 将 MAX_RUNTIME 设置为 1,800 秒指定了 SageMaker 训练我们的模型的最大时间

在您运行 CREATE MODEL 命令后，运行以下命令以检查模型的状态：

SHOW MODEL chapter5_buildfirstmodel.customer_churn_model;

Redshift ML 的 CREATE MODEL 语句是异步的，这意味着当模型处于训练状态时，查询显示已完成，而训练正在 Amazon SageMaker 中进行。要了解模型的状态，请运行 SHOW MODEL 命令。

在以下屏幕截图中，您可以看到 SHOW MODEL 输出显示 模型状态 为 训练：

图 5.6 – 模型状态训练

在一段时间后运行相同的SHOW MODEL命令后，模型状态显示为READY，这意味着数据处理、模型训练、模型选择和模型部署到 Redshift 已成功完成。从以下屏幕截图，您可以看到模型状态现在显示为READY。您还可以看到预估成本值，这代表 Amazon SageMaker 训练小时数。这个值不等于已过训练时间，因为它是在 SageMaker 实例上累积的训练时间。

图 5.7 – 模型状态为 READY

除了SHOW MODEL命令提供有关模型的其它有用信息外，例如，查询使用情况、目标列、模型类型和预测时使用的函数名称。您可以看到，在我们的示例中模型类型是xgboost，这表明 Amazon SageMaker 已选择 XGBoost 算法来构建二元分类模型：

图 5.8 – 模型状态为 READY 的延续

如果您进一步阅读输出，Redshift ML 已经为您做了大部分工作，例如，它已选择并设置了以下参数：

• 问题类型设置为二元分类。这是真的，因为我们的目标变量中有两个不同的值，即 true 和 false。因此，这是一个二元分类问题。

• 验证和目标设置为F1。F1 分数是评估二元分数时推荐的方法，因为它考虑了精确度和召回率。SageMaker Autopilot 可能为二元分类模型选择的其它目标还包括准确率和曲线下面积（AUC）。

我们已成功创建模型，作为SELECT查询。下一节将展示如何做到这一点。

评估模型性能

现在我们已经创建了模型，让我们深入了解其性能细节。

在构建机器学习模型时，了解模型性能非常重要。您这样做是为了确保您的模型是有用的，并且不会对某一类有偏见，以及确保模型不是欠训练或过训练，这意味着模型要么没有正确预测类别，要么只预测了一些实例而没有预测其他实例。

为了解决这个问题，Redshift ML 提供了各种目标来衡量模型的性能。我们明智的做法是使用上一节中预留的测试数据集来测试模型性能。本节将解释如何审查 Redshift ML 目标，并使用我们的测试数据验证模型性能。

Redshift ML 使用几种目标方法来衡量机器学习模型的预测质量。

检查 Redshift ML 目标

图 5.9 显示了 SHOW MODEL 的输出。它显示了两个对我们来说有趣的价值。一个是 Objective，另一个是 validation:f1_binary。首先需要查看的是 Objective。它被设置为 F1。F1 或 F-score 是分类模型中最常用的性能评估指标。它是验证数据集准确性的一个度量。它是从验证的精确度和召回率计算得出的，其中精确度是真实阳性结果的数量除以所有阳性结果的数量，召回率是真实阳性结果的数量除以所有应被识别为阳性的记录的数量。您可以在这里了解更多关于 F-score 的信息：en.wikipedia.org/wiki/F-score。

在查询编辑器 v2 中运行以下命令：

SHOW MODEL chapter5_buildfirstmodel.customer_churn_model;

图 5.9 中的输出显示了 F1 的值位于 validation:f1_binary 中，其值为 0.90。F1 分数的最高可能值为 1，最低为 0。得分为 1 表示模型具有完美的精确度和召回率。在我们的情况下，它是 90%，这非常好。

图 5.9 – 模型目标值

我们已经看到，由 Autopilot 创建的模型具有很好的 F-score，并且可以用来预测客户是否会流失。在下一节中，我们将使用预测函数来生成预测值以及概率分数。

运行预测

现在，让我们通过 SELECT 命令调用我们的 predict_customer_churn 和 predict_customer_churn_prob 预测函数。Redshift ML 为我们创建了两个函数来使用：

• 其中一个与我们在创建模型时给出的名称相同，在本例中为 predict_customer_churn，它返回类别标签或预测值，例如，0 或 1。

• 另一个函数 predict_customer_churn_prob，除了返回类别标签或预测值外，还返回预测值正确的概率。

要测试这些函数，请运行以下查询。在以下查询中，您会注意到我们在 SELECT 命令中使用两个预测函数，并传递创建 ML 模型时传递的所有输入列。这两个函数将返回标签和概率分数作为输出。我们还通过过滤 record_date 大于 '2022-07-31' 的行来测试预测函数。由于这是一个未见过的数据集，它应该作为对我们 ML 模型具有挑战性的数据集。

还需要注意的是，所有预测都是在 Redshift 集群上本地进行的。当运行 SELECT 查询时，没有调用 Amazon SageMaker。这使得所有预测都是免费的：

SELECT area_code ||phone  accountid, replace(churn,'.','') as Actual_churn_class,
    chapter5_buildfirstmodel.predict_customer_churn(
      state,account_length,area_code, phone,intl_plan,
      vMail_plan, vMail_message, day_mins, day_calls,
      day_charge, total_charge, eve_mins, eve_calls,
      eve_charge, night_mins, night_calls,
      night_charge, intl_mins, intl_calls, intl_charge,
      cust_serv_calls) AS predicted_class,
      chapter5_buildfirstmodel.predict_customer_churn_prob(
      state, account_length, area_code, phone, intl_plan,
      vMail_plan, vMail_message, day_mins, day_calls,
      day_charge, total_charge, eve_mins, eve_calls,
      eve_charge, night_mins, night_calls,night_charge,
      intl_mins, intl_calls, intl_charge, cust_serv_calls)
      AS probability_score
  FROM chapter5_buildfirstmodel.customer_calls_fact
WHERE record_date > '2020-07-31'
;

您可以在以下屏幕截图中查看输出：

图 5.10 – 运行预测

在前面的屏幕截图中，请注意，每个客户的predicted_class值和probability_score值都显示出来。从predicted_class列中，您可以理解我们的模型正在预测客户是否会流失，而从probability_score列中，您可以理解模型，例如，对于第一行，模型有 99%的信心认为账户 ID 为415382-4657的客户不会流失。

我们已经见证了预测工作没有出现任何问题。在下一节中，我们将检查模型与真实值相比的表现。

比较真实值与预测值

运行以下查询以比较实际与预测的客户流失：

WITH infer_data AS (
  SELECT area_code ||phone  accounted,
    replace(churn,'.','') as churn,
    chapter5_buildfirstmodel.predict_customer_churn(
              state,
              account_length,
              area_code,
              phone,
              intl_plan,
              vMail_plan,
              vMail_message,
              day_mins,
              day_calls,
              day_charge,
              total_charge,
              eve_mins,
              eve_calls,
              eve_charge,
              night_mins,
              night_calls,
              night_charge,
              intl_mins,
              intl_calls,
              intl_charge,
              cust_serv_calls) AS predicted
  FROM chapter5_buildfirstmodel.customer_calls_fact
WHERE record_date > '2020-07-31'
)
SELECT *  FROM infer_data where churn!=predicted;

以下屏幕截图显示了 ML 模型犯错的客户：

注意

结果将因每个训练模型略有不同而有所变化。

图 5.11 – 错误预测

我们已经看到了模型预测，并与真实值进行了比较。在下一节中，我们将学习关于特征重要性的内容。

特征重要性

explain_model函数用于检索特征重要性。这将帮助您了解哪些特征与目标变量高度相关，哪些特征对模型很重要，哪些则不是，从而您可以减少输入到机器学习模型中的维度数量。

以下是可以运行的 SQL 代码，用于检索我们模型的特征重要性：

Select jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata ;

以下是特征重要性的 JSON 格式输出。您可以阅读和理解每个特征的重要性。

图 5.12 – 特征重要性原始输出

为了更好地阅读特征重要性，您可以执行以下 SQL 代码：

select t1.feature_imp, t1.value from
(
Select
'account_length' as feature_imp,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.account_length as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'area_code' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.area_code as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'cust_serv_calls' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.cust_serv_calls as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'day_calls' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.day_calls as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'day_charge' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.day_charge as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata 
union
select 'day_mins' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.day_mins as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'eve_calls' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.eve_calls  as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'eve_charge' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.eve_charge  as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'eve_mins' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.eve_mins  as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'intl_calls' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.intl_calls   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'intl_charge' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.intl_charge   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'intl_mins' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.intl_mins    as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'intl_plan' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.intl_plan     as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'inight_calls' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.night_calls     as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'night_charge' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.night_charge    as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'night_mins' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.night_mins   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'phone' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.phone   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'state' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.state   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'total_charge' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.total_charge   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'vmail_message' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.vmail_message   as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
union
select 'vmail_plan' as feature_imp ,
jsondata.featureimp.explanations.kernel_shap.label0.global_shap_values.vmail_plan  as value
from ( select explain_model( 'chapter5_buildfirstmodel.customer_churn_model')as featureimp) jsondata
) t1
order by value desc

图 5.13 – 特征重要性

您可以使用特征重要性来理解每个特征与目标变量之间的关系，以及哪些特征不重要。

我们已经看到了对模型贡献很大的特征，现在让我们看看模型性能指标是如何在我们的测试数据集上计算的。

模型性能

让我们使用 Redshift SQL 计算一个混淆矩阵来评估分类模型的表现。使用混淆矩阵，您可以识别真实正例、真实负例、假正例和假负例，基于这些，可以计算出各种统计指标，如准确率、精确率、召回率、灵敏度、特异性和最终，F1 分数。您可以在此处了解更多关于混淆矩阵的概念：en.wikipedia.org/wiki/Confusion_matrix。

以下查询使用了WITH子句，这在 Redshift 中实现了公共表表达式。此查询包含以下三个部分：

• 第一部分是关于WITH子句中的SELECT语句，在这里我们预测客户流失并保存在内存中。这个数据集被命名为infer_data。

• 第二部分位于第一个SELECT语句下方，读取infer_data并构建混淆矩阵，这些详细信息存储在名为confusionmatrix的数据集中。

• 在语句的第三部分，请注意，SELECT语句构建了模型性能指标，如 F1 分数、准确率、召回率等。

运行以下查询以构建测试数据集的混淆矩阵：

WITH infer_data AS (
  SELECT area_code ||phone  accountid, replace(churn,'.','') as churn,
    chapter5_buildfirstmodel.predict_customer_churn(
          state,  account_length, area_code, phone,
          intl_plan, vMail_plan, vMail_message, day_mins,
          day_calls,  day_charge, total_charge, eve_mins,
          eve_calls, eve_charge, night_mins, night_calls,
          night_charge, intl_mins, intl_calls,
          intl_charge,   cust_serv_calls) AS predicted
  FROM chapter5_buildfirstmodel.customer_calls_fact
WHERE record_date > '2020-07-31'),
confusionmatrix as
(
SELECT case when churn  ='True' and predicted = 'True' then 1 else 0 end TruePositives,
case when churn ='False' and predicted = 'False' then 1 else 0 end TrueNegatives,
case when churn ='False' and predicted = 'True' then 1 else 0 end FalsePositives,
case when churn ='True' and predicted = 'False' then 1 else 0 end FalseNegatives
  FROM infer_data
 )
select
sum(TruePositives+TrueNegatives)*1.00/(count(*)*1.00) as Accuracy,--accuracy of the model,
sum(FalsePositives+FalseNegatives)*1.00/count(*)*1.00 as Error_Rate, --how often model is wrong,
sum(TruePositives)*1.00/sum (TruePositives+FalseNegatives) *1.00 as True_Positive_Rate, --or recall how often corrects are rights,
sum(FalsePositives)*1.00/sum (FalsePositives+TrueNegatives )*1.00 False_Positive_Rate, --or fall-out how often model said yes when it is no,
sum(TrueNegatives)*1.00/sum (FalsePositives+TrueNegatives)*1.00 True_Negative_Rate, --or specificity, how often model said no when it is yes,
sum(TruePositives)*1.00 / (sum (TruePositives+FalsePositives)*1.00) as Precision, -- when said yes how it is correct,
2*((True_Positive_Rate*Precision)/ (True_Positive_Rate+Precision) ) as F_Score --weighted avg of TPR & FPR
From confusionmatrix
;

我们得到以下输出：

图 5.14 – 测试数据集的混淆矩阵

通过查看record_date > '2020-07-31')）。这些记录之前没有被模型看到，但 97%的时间，模型能够正确预测类值。这证明了模型是有用的，并且能够正确预测两个类别——流失和非流失。现在可以将这个模型交给业务部门，以便它可以主动预测即将流失的客户并为他们制定营销活动。

摘要

在本章中，你学习了如何使用简单的CREATE MODEL语句创建你的第一个机器学习模型。在这个过程中，你使用了查询编辑器 v2 来探索customer_calls_fact表数据，了解了CREATE MODEL语句的基本语法，创建了一个简单的 ML 模型，学习了如何读取模型的输出，并最终使用 Redshift SQL 自己计算了一些模型评估指标。

在下一章中，你将使用本章学到的基本知识来使用 Redshift ML 构建各种分类模型。

第六章：构建分类模型

在本章中，你将了解在 机器学习（ML）中使用的分类算法。你将了解 Redshift 在创建分类模型时提供的各种方法。本章将提供二元和多类别分类模型的详细示例，并展示如何使用这些建模技术解决业务问题。到本章结束时，你将能够确定一个业务问题是否为分类问题，确定 Redshift 在训练中提供的正确方法，并构建模型。

在本章中，我们将讨论以下主要内容：

• 分类算法简介

• 创建带有用户指导的模型语法

• 使用 XGBoost 算法训练二元分类模型

• 使用线性学习器模型类型训练多类别分类模型

技术要求

本章需要网络浏览器以及访问以下内容：

• 一个 AWS 账户

• 一个 Amazon Redshift 无服务器端点

• Amazon Redshift 查询编辑器 v2

• 完成 第一章 中的 Amazon Redshift 无服务器入门 部分

你可以在此处找到本章使用的代码：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/.

分类算法简介

分类是将任何实体或类别进行分类的过程，以便更好地理解和分析。分类过程通常作为预设置的业务流程的一部分发生（例如，在观察产品后将其标记为有缺陷或良好），或通过退货流程（例如，在客户将产品退回为有缺陷后将其标记为有缺陷）。在任何情况下，重要的是对实体进行分类——在这种情况下，将产品分类到类别中（即，有缺陷或无缺陷）。

图 6.1 展示了使用三个输入变量被分类到两个类别的数据。该图显示了输入和输出数据点被分类到两个类别的情况。当输出标签只包含两个类别时，它被称为二元 分类问题：

图 6.1 – 二元分类

如果输出变量包含两个以上的类别——例如，预测一个水果是苹果、橙子还是梨——那么它被称为多类别分类。图 6.2 展示了基于三个输入变量被分类到多个类别的数据。该图显示了一个多类别分类图，说明了输入和输出对如何被分类到三个类别：

图 6.2 – 多类别分类

分类过程也可以发生在尚未定义类别的数据上。让我们继续了解这是如何可能的。

并非总是您的实体以某种方式分组或分类。例如，如果您想分析客户的购买历史或点击流活动，或者如果您想根据人口统计或购物行为将类似客户分组，那么分类算法就派上用场，用于分析数据并将相似数据点聚类。这种类型的分类建模称为 无监督学习。

建立类别有助于分析过程——例如，一旦产品被标记为某个类别标签，您就可以轻松检索出退货的次品产品列表，然后进一步研究其特征，例如商店位置、退货产品的客户的 demographics 以及产品退货最多的季节。如何以及何时定义和建立类别，使企业能够进行深入分析，不仅回答诸如在哪里和什么的问题，而且还在历史数据和类别上训练 ML 模型，并预测实体将落入哪个类别。

常见的分类模型有用武之地的场景包括以下几种：

• 客户行为预测

• 文档或图像分类

• 防垃圾邮件过滤

在本章中，我们将向您展示如何创建 Redshift 提供的不同分类模型。Amazon Redshift 提供了 XGBoost、多层感知器（MLP）和 线性学习器算法来训练和构建分类模型。

在本章中，您将通过构建二元分类模型开始学习监督分类模型，使用 XGBoost 和使用线性学习器的多类别分类模型。MLP 模型将在 第九章 中介绍，而无监督分类建模将在 第八章 中介绍。

现在，我们将向您详细介绍使用 Redshift ML 创建模型的详细语法。

深入了解 Redshift 的 CREATE MODEL 语法

在 第四章 中，我们看到了 Redshift CREATE MODEL 命令的不同变体以及数据分析师、公民数据科学家或数据科学家如何以不同复杂度操作 CREATE MODEL 命令。在本节中，我们将向您介绍一个公民数据科学家角色，他并不完全了解统计学，但对识别要使用的算法和可以将哪种问题类型应用于业务问题有很好的了解。在 Redshift ML 世界中，这种类型的模型创建被称为 带有用户指导的 CREATE MODEL。

正如前文所述，我们将探索CREATE MODEL语句中的模型类型和问题类型参数。作为CREATE MODEL with user guidance的一部分，您还可以选择设置一个预处理程序，但我们将把这个话题留到第十章中。

作为 ML 模型创建者，您将决定使用哪种算法以及解决哪种问题类型。Redshift ML 仍然在幕后执行独立变量的特征工程。例如，在 20 个特征中，Redshift ML 将自动识别分类变量和数值变量，并在适用的情况下创建单热编码值或数值变量的标准化，以及完成模型训练所需的各种其他任务。

总结来说，您让 Redshift ML 处理大部分数据准备任务。作为模型创建者，您提出要使用的算法和要解决的问题类型。通过预选算法类型和问题类型，Redshift ML 将减少训练类型，因为它将在其他算法和问题类型上训练模型。与我们在第五章中创建的完整AUTO CREATE MODEL语句相比，带有用户指导的 CREATE MODEL需要更少的时间。

如前文所述，我们将使用 XGBoost 算法进行二元分类，使用线性学习器算法进行多类分类。

您可以在以下链接中了解更多关于 XGBoost 的信息：docs.aws.amazon.com/sagemaker/latest/dg/XGBoost.html。

您还可以在以下链接中了解更多关于 Linear Learner 的信息：docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html。

使用简单的CREATE MODEL语句，Redshift ML 将使用 SageMaker Autopilot 自动确定问题类型、算法以及最佳模型类型。

使用 Redshift ML，您可以通过提供用户指导来影响模型。当您发出CREATE MODEL语句时，您可以选择model_type、problem_type和objective。您可以在以下链接中找到关于语法和选项的更多详细信息：docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html。

到目前为止，我们已经讨论了 Redshift ML CREATE MODEL语法的基础知识以及您如何提供指导，例如模型类型和目标，或者选择让 Redshift ML 自动为您选择这些。

现在，您将学习如何创建一个二元分类模型并指定 XGBoost 算法。

使用 XGBoost 算法训练二元分类模型

二分类模型用于解决预测两个可能类别中的一个类别的问题——例如，预测是否会下雨。目标是了解过去的数据点，并确定特定数据点将落入哪个目标桶中。二分类模型的典型用例如下：

• 预测患者是否患有疾病

• 预测客户是否会流失

• 预测行为——例如，客户是否会提出上诉

在接下来的几节中，我们将通过以下步骤来实现创建用于运行推理查询的二分类模型的目标：

1. 定义业务问题

2. 上传和分析数据

3. 创建模型

4. 对模型运行预测查询

确立业务问题

为了构建我们的二分类问题，我们将研究一个银行营销问题。银行在针对客户的营销活动中投入了大量资金，以便他们订阅其产品。银行在营销活动中建立效率非常重要，这可以通过学习最后的市场营销数据集并预测未来的营销结果来实现。我们将致力于预测银行客户是否会订阅银行产品的定期存款优惠。

上传和分析数据

在本节中，我们将研究一个银行营销数据集。这些数据与葡萄牙一家银行的直接营销活动相关。想象一下，你是一名营销分析师，你的目标是通过对客户提供定期存款来增加存款额。确保营销活动针对适当的客户是非常重要的。你将使用 Redshift ML 创建一个模型，以预测客户是否可能接受定期存款的优惠。此数据集来源于archive.ics.uci.edu/ml/datasets/bank+marketing。

数据集引用

[Moro 等人，2014] S. Moro, P. Cortez 和 P. Rita. 基于数据驱动的银行电话营销成功率预测方法，《决策支持系统》，Elsevier，62:22–31，2014 年 6 月

分类目标是预测客户是否会（是/否）订阅定期存款（y变量）。

数据集包含诸如年龄、工作、婚姻状况、教育水平和就业状况等列。

这些列的元数据也可以在 UCI ML 仓库网站上找到：archive.ics.uci.edu/ml/datasets/bank+marketing。

如前述链接所示，有 20 个独立变量和 1 个因变量（y）。我们可以将这些独立变量中的任何一个或全部作为CREATE MODEL语句的输入，以便预测结果，y表示客户是否可能接受该优惠。

在成功连接到 Redshift 作为管理员或数据库开发者后，按照以下步骤创建模式并将数据加载到 Amazon Redshift 中：

1. 导航到 Redshift 查询编辑器 v2，并连接到 无服务器 端点和 dev 数据库。

2. 重命名 Chap6。

以下截图显示了无服务器连接，数据库设置为 dev，查询编辑器页面保存为 Chap6：

图 6.3 – Query Editor v2

1. 现在，使用以下代码行创建模式。此模式是创建和维持本章所需的所有表和数据的地方：

   Create schema chapter6_supervisedclassification;
   

你将看到如下输出，表示你的模式已创建：

图 6.4 – 创建的模式

以下代码将创建 bank_details_training 表以存储用于训练模型的数据，以及 bank_details_inference 表以存储用于运行推理查询的数据。请注意，我们已经将我们的输入数据集分割成这两个数据集供你使用。本章中使用的所有 SQL 命令都可以在这里找到：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter6/chapter6.sql。

1. 从 GitHub 运行以下代码以在 Query Editor v2 中创建训练和推理表：

   CREATE TABLE chapter6_supervisedclassification.bank_details_training(
   

      age numeric, "job" varchar marital varchar, education varchar,
   

      "default" varchar, housing varchar, loan varchar,
   

      contact varchar, month varchar, day_of_week varchar,
   

      …,
   

      y boolean ) ;
   

   --create table to store data for running predictions
   

   CREATE TABLE chapter6_supervisedclassification.bank_details_inference(
   

      age numeric, "job" varchar marital varchar, education varchar,
   

      "default" varchar, housing varchar, loan varchar,
   

      contact varchar, month varchar, day_of_week varchar,
   

      …,
   

      y boolean ) ;
   

你将看到如下输出以验证你的表已成功创建：

图 6.5 – 成功创建的表

现在你已经创建了表，请使用 Query Editor v2 运行 步骤 5 中的命令来加载数据，使用提供的 S3 存储桶。

1. 使用以下命令将样本数据加载到在 步骤 4 中创建的表中，该命令可在 GitHub 上找到。请注意，我们使用 COPY 命令从 Amazon S3 加载数据：

   --load data into  bank_details_inference
   

   TRUNCATE chapter6_supervisedclassification.bank_details_inference;
   

    COPY chapter6_supervisedclassification.bank_details_inference from 's3://packt-serverless-ml-redshift/chapter06/bank-marketing-data/inference-data/inference.csv' REGION 'eu-west-1' IAM_ROLE default CSV IGNOREHEADER 1 delimiter ';';
   

   -- load data into bank_details_training
   

   TRUNCATE chapter6_supervisedclassification.bank_details_training;
   

    COPY chapter6_supervisedclassification.bank_details_training from 's3://packt-serverless-ml-redshift/chapter06/bank-marketing-data/training-data/training.csv' REGION 'eu-west-1' IAM_ROLE default CSV IGNOREHEADER 1 delimiter ';';
   

2. 通过创建直方图图表分析客户定期存款订阅表。首先，再次使用 Query Editor v2 运行以下命令：

   SELECT y, COUNT(*) Customer_Count FROM chapter6_supervisedclassification.bank_details_training
   

   GROUP BY y
   

   ;
   

你可以在结果集中看到，36548 名客户没有选择银行的优惠，而 4640 名客户接受了。你还可以使用 Query Editor v2 中的图表功能创建条形图。在 结果 面板右侧点击 图表 选项：

图 6.6 – 订阅结果和图表选项

选择 类型 为 条形图，X 值为 y，Y 值为 customer_count 后，你将得到以下结果：

图 6.7 – 客户接受度图表

现在我们已经加载数据，我们可以创建我们的模型。

使用 XGBoost 训练二元分类模型

在本节中，您将指定MODEL_TYPE和PROBLEM_TYPE以使用 XGBoost 算法创建一个二元分类模型。我们现在将讨论银行营销活动问题。该模型的目标是预测客户是否会订阅定期存款。

我们将MODEL_TYPE设置为XGBoost，将PROBLEM_TYPE设置为BINARY_CLASSIFICATION。我们将使用默认的IAM_ROLE。此外，我们还需要指定模型工件将存储的 S3 桶，并且另外设置MAX_RUNTIME为3600（秒）。

以下是为创建模型编写的代码。您将在github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/chapter6.sql找到完整的代码以及本章所需的全部 SQL 命令：

DROP MODEL chapter6_supervisedclassification.banking_termdeposit;
CREATE  MODEL chapter6_supervisedclassification.banking_termdeposit
FROM (
SELECT
   age ,
   "job" ,
   marital ,
   education ,
   "default" ,
   housing ,
   loan ,
   contact ,
   month ,
   day_of_week ,
   duration,
   campaign ,
   pdays ,
   previous ,
   poutcome ,
   emp_var_rate ,
   cons_price_idx ,
   cons_conf_idx ,
   euribor3m ,
   nr_employed ,
   y
FROM
    chapter6_supervisedclassification.bank_details_training )
    TARGET y
FUNCTION predict_term_deposit
IAM_ROLE default
MODEL_TYPE XGBoost
PROBLEM_TYPE BINARY_CLASSIFICATION
SETTINGS (
  S3_BUCKET '<<your-S3-Bucket',
  MAX_RUNTIME 9600
  )
;

通过将MODEL_TYPE设置为XGBoost并将PROBLEM_TYPE设置为BINARY_CLASSIFICATION，我们指导 Redshift ML 仅在这次训练运行中搜索最佳的 XGBoost 模型。如果保留为默认值，Redshift ML 将检查是否可以将其他分类模型应用于数据集。

由于SageMaker AutoPilot 算法无需测试其他模型类型或确定问题类型，因此最终结果将减少训练时间。在本例中，SageMaker Autopilot 负责选择目标类型、调整超参数和处理数据预处理步骤。

要检查模型的状态，请运行以下命令：

SHOW MODEL chapter6_supervisedclassification.banking_termdeposit;

您将得到以下结果：

图 6.8 – 显示模型输出

从前面的屏幕截图可以看出，模型仍在训练中。此外，请注意 Redshift ML 拾取了CREATE MODEL语句。其他参数，如目标、超参数和预处理，仍然由 Redshift ML 自动处理。

在函数名称下的predict_term_deposit参数用于生成预测，我们将在下一节中使用它。

在一段时间后再次运行SHOW MODEL命令，以检查模型训练是否完成。从以下屏幕截图可以看出，模型状态为就绪，并且F1已被选为模型评估的目标。F1分数为0.646200，或 64%。这个数字越接近 1，模型分数就越好：

图 6.9 – 显示模型输出

让我们针对我们的训练数据运行以下查询以验证 F1 分数：

WITH infer_data
 AS (
    SELECT  y as actual, chapter6_supervisedclassification.predict_term_deposit(
   age ,   "job" ,   marital ,   education ,   "default" ,   housing ,   loan ,   contact ,   month ,   day_of_week ,   duration ,   campaign ,   pdays ,   previous ,   poutcome ,   emp_var_rate ,   cons_price_idx ,        cons_conf_idx ,        euribor3m ,   nr_employed
) AS predicted,
     CASE WHEN actual = predicted THEN 1::INT
         ELSE 0::INT END AS correct
    FROM chapter6_supervisedclassification.bank_details_training
    ),
 aggr_data AS (
     SELECT SUM(correct) as num_correct, COUNT(*) as total FROM infer_data
 )
 SELECT (num_correct::float/total::float) AS accuracy FROM aggr_data;

您可以在以下输出中看到，我们的准确度非常好，接近 94%：

图 6.10 – 准确度结果

现在模型训练已完成，我们将使用创建的函数来运行预测查询。

运行预测

让我们在我们的推理数据集上运行一些预测，以查看有多少客户被预测为订阅定期存款。在 Query Editor v2 中运行以下 SQL 语句：

WITH term_data AS ( SELECT chapter6_supervisedclassification.predict_term_deposit( age,"job" ,marital,education,"default",housing,loan,contact,month,day_of_week,duration,campaign,pdays,previous,poutcome,emp_var_rate,cons_price_idx,cons_conf_idx,euribor3m,nr_employed) AS predicted
FROM chapter6_supervisedclassification.bank_details_inference )
SELECT
CASE WHEN predicted = 'Y'  THEN 'Yes-will-do-a-term-deposit'
     WHEN predicted = 'N'  THEN 'No-term-deposit'
     ELSE 'Neither' END as deposit_prediction,
COUNT(1) AS count
from term_data GROUP BY 1;

您应该得到以下输出：

图 6.11 – 预测结果

我们可以看到642名客户被预测为会接受定期存款订阅的报价，而3477名客户被预测为不会接受报价。

预测概率

Amazon Redshift ML 现在提供了获取二元和多类分类问题预测概率的能力。请注意，在图 6.9 的SHOW MODEL命令输出中，已创建一个名为predict_term_deposit_prob的附加函数名。运行以下查询以检查已婚且从事管理工作且年龄在 35 至 45 岁之间的客户接受定期存款报价的概率：

SELECT
age,"job" ,marital ,
chapter6_supervisedclassification.predict_term_deposit_prob( age,"job" ,marital,education,"default",housing,loan,contact,month,day_of_week,duration,campaign,pdays,previous,poutcome,emp_var_rate,cons_price_idx,cons_conf_idx,euribor3m,nr_employed) AS predicted
FROM chapter6_supervisedclassification.bank_details_inference
where marital = 'married'
  and "job" = 'management'
  and age between 35 and 40;

您将看到以下结果：

图 6.12 – 概率结果

您可以看到第一行有一个0.99985629的错误预测概率，以及只有0.00014372的正确预测概率。

您还可以修改前面的查询以查看被预测为接受定期存款报价的客户概率。在 Query Editor v2 中运行以下 SQL 命令：

SELECT age, "job", marital, predicted.labels[0], predicted.probabilities[0]
from
 (select
age,"job" ,marital ,
chapter6_supervisedclassification.predict_term_deposit_prob( age,"job" ,marital,education,"default",housing,loan,contact,month,day_of_week,duration,campaign,pdays,previous,poutcome,emp_var_rate,cons_price_idx,cons_conf_idx,euribor3m,nr_employed) AS predicted
FROM chapter6_supervisedclassification.bank_details_inference
where marital = 'married'
  and "job" = 'management'
  and age between 35 and 40) t1
where predicted.labels[0] = 't';

您将看到以下类似的结果：

图 6.13 – 客户接受条款报价的概率结果

在第五章中，您学习了如何通过运行可解释性报告来确定特征重要性。运行以下查询以查看哪些输入对模型预测贡献最大：

select json_table.report.explanations.kernel_shap.label0.global_shap_values from
 (select explain_model('chapter6_supervisedclassification.banking_termdeposit') as report) as json_table;

将结果复制到编辑器中，以便更容易阅读，如图6.14 所示：

图 6.14 – 可解释性报告

这表明pdays的重要性最高，而poutcome的重要性最低。

现在您已经构建了一个二元分类模型，让我们继续尝试构建一个多类分类模型。

使用线性学习模型类型训练多类分类模型

在本节中，您将学习如何使用线性学习算法在 Amazon Redshift ML 中构建多类分类模型。

要做到这一点，我们将使用来自 Kaggle 的客户细分数据集：www.kaggle.com/datasets/vetrirah/customer。

您将使用此数据集来训练一个模型，将客户分类到四个细分市场之一（A、B、C或D）。通过细分客户，您可以更好地了解客户，并对他们进行有针对性的营销，提供与他们相关的产品。

我们的数据已经分为训练集和测试集，并存储在以下 S3 位置：

• s3://packt-serverless-ml-redshift/chapter06/segmentation/train.csv

• s3://packt-serverless-ml-redshift/chapter06/segmentation/test.csv

在成功连接到 Redshift 作为管理员或数据库开发者后，按照以下方式将数据加载到 Amazon Redshift 中：

1. 导航到 Redshift 查询编辑器 v2，并连接到 无服务器 端点和 dev 数据库。

2. 使用为二进制分类练习创建的相同模式和查询编辑器页面（见 上传和分析数据 部分）。

使用以下 SQL 命令在 Query Editor v2 中创建训练表和测试表并加载数据。这些 SQL 命令可以在

github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter6/chapter6.sql:

CREATE TABLE chapter6_supervisedclassification.cust_segmentation_train (
    id numeric,
    gender varchar,
    ever_married  varchar,
    age numeric,
    graduated varchar,
    profession varchar,
    work_experience numeric,
    spending_score  varchar,
    family_size numeric,
    var_1 varchar,
    segmentation varchar
)
DISTSTYLE AUTO;
COPY chapter6_supervisedclassification.cust_segmentation_train FROM 's3://packt-serverless-ml-redshift/chapter06/Train.csv' IAM_ROLE DEFAULT FORMAT AS CSV DELIMITER ',' QUOTE '"' IGNOREHEADER 1 REGION AS 'eu-west-1';
CREATE TABLE chapter6_supervisedclassification.cust_segmentation_test (
    id numeric,
    gender varchar,
    ever_married  varchar,
    age numeric,
    graduated varchar,
    profession varchar,
    work_experience numeric,
    spending_score  varchar,
    family_size numeric,
    var_1 varchar
)
DISTSTYLE AUTO;
COPY chapter6_supervisedclassification.cust_segmentation_test FROM 's3://packt-serverless-ml-redshift/chapter06/Test.csv' IAM_ROLE DEFAULT FORMAT AS CSV DELIMITER ',' QUOTE '"' IGNOREHEADER 1 REGION AS 'eu-west-1';

现在数据已经加载，让我们对我们的训练数据进行一些分析。

1. 通过执行以下 SQL 命令分析训练数据：

   select segmentation, count(*)  from chapter6_supervisedclassification.cust_segmentation_train
   

   group by 1;
   

您应该得到以下输出：

图 6.15 – 分割

我们的训练数据集总共有 8,068 条客户记录。从这个样本中，我们可以看到细分 C、B 和 A 非常相似，并且更多客户位于细分 D 中。

我们将使用训练数据集的输入来预测客户细分，使用线性学习器算法。

使用线性学习器预测客户细分

线性学习器是一种监督学习算法，是您可以使用来解决分类或回归问题的模型类型之一。

对于多类分类问题，与二进制分类问题的确切两个标签相比，我们将尝试预测的标签（或目标）超过两个。我们将向您展示如何使用线性学习器在 第七章 中解决回归问题。

使用线性学习器，与传统的超参数优化技术相比，你可以实现速度的显著提升，这使得它非常方便。

我们将提供一个包含我们的输入或关于数据的观察以及代表我们想要预测的值的标签的训练集。我们可以选择性地为某些列的组合提供预处理器。

在本节中，您将通过提供 MODEL_TYPE、PROBLEM_TYPE 和 OBJECTIVE 来应用用户指导技术，使用线性学习器算法创建一个多类分类模型。该模型的目标是预测每个客户的细分。

我们将设置 MODEL_TYPE 为 LINEAR_LEARNER 和 PROBLEM_TYPE 为 MULTICLASS_CLASSIFICATION。我们将其他选项保留为默认设置。

让我们在 Query Editor v2 中执行以下代码来训练模型：

CREATE  MODEL chapter6_supervisedclassification.cust_segmentation_model_ll
FROM (
SELECT
    id, gender, ever_married, age, graduated,profession,
    work_experience, spending_score,family_size,
    var_1,segmentation
FROM chapter6_supervisedclassification.cust_segmentation_train
)
TARGET segmentation
FUNCTION predict_cust_segment_ll   IAM_ROLE default
MODEL_TYPE LINEAR_LEARNER
PROBLEM_TYPE MULTICLASS_CLASSIFICATION
OBJECTIVE 'accuracy'
SETTINGS (
  S3_BUCKET '<<your-s3-bucket>>',
  S3_GARBAGE_COLLECT OFF,
  MAX_RUNTIME 9600
  );

要检查模型的状态，请在 Query Editor v2 中运行以下命令：

SHOW MODEL chapter6_supervisedclassification.cust_segmentation_model_ll;

你应该得到以下输出：

图 6.16 – 显示模型输出

你可以看到模型现在在CREATE MODEL语句中。

现在模型已经训练好了，是时候评估其质量了。

评估模型质量

当你发出CREATE MODEL命令时，Amazon SageMaker 会自动在后台将你的数据分为测试和训练，以便确定模型的准确度。如果你查看SHOW MODEL输出的validation:multiclass_accuracy键，你会看到一个值为0.535028，这意味着我们的模型可以在 53%的时间内正确选择细分市场。理想情况下，我们更喜欢接近 1 的值。

我们还可以运行一个验证查询来检查我们的准确率。在以下查询中，请注意我们选择了实际的细分，然后我们使用由我们的CREATE MODEL命令生成的函数来获取预测的细分以进行比较：

 select
 cast(sum(t1.match)as decimal(7,2)) as predicted_matches
,cast(sum(t1.nonmatch) as decimal(7,2)) as predicted_non_matches
,cast(sum(t1.match + t1.nonmatch) as decimal(7,2))  as total_predictions
,predicted_matches / total_predictions as pct_accuracy
from
(SELECT
    id,
    gender,
    ever_married,
    age,
    graduated,
    profession,
    work_experience,
    spending_score,
    family_size,
    var_1,
    segmentation as actual_segmentation,
    chapter6_supervisedclassification.predict_cust_segment_ll
(id,gender,ever_married,age,graduated,profession,work_experience,
spending_score,family_size,var_1) as predicted_segmentation,
    case when actual_segmentation = predicted_segmentation then 1
      else 0 end as match,
  case when actual_segmentation <> predicted_segmentation then 1
    else 0 end as nonmatch
    FROM chapter6_supervisedclassification.cust_segmentation_train
) t1;

我们得到以下输出：

图 6.17 – 模型准确度

这个输出显示，当我们比较模型正确预测细分市场的次数与总输入记录数时，我们非常接近.535028的分数。

现在我们已经检查了模型准确度，我们就可以运行针对测试数据集的预测查询了。

运行预测查询

现在我们有了模型并进行了验证，我们可以运行预测查询来测试集，以便根据客户 ID 对潜在客户进行细分。你可以看到我们现在使用我们的函数对测试表进行操作以获取预测的细分：

SELECT
id,
chapter6_supervisedclassification.predict_cust_segment_ll
(id,gender,ever_married,age,graduated,profession,work_experience,spending_score,family_size,var_1) as  segmentation
FROM chapter6_supervisedclassification.cust_segmentation_test;

这里显示了前 10 位客户：

图 6.18 – 预测的细分市场

让我们看看新潜在客户是如何分布在各个细分市场中的：

SELECT
    chapter6_supervisedclassification.predict_cust_segment_ll
    (id,gender,ever_married,age,graduated,profession,work_experience,spending_score,family_size,var_1) as  segmentation,
    count(*)
    FROM chapter6_supervisedclassification.cust_segmentation_test
   group by 1;

我们可以看到每个细分市场中有多少潜在客户：

图 6.19 – 按细分市场的客户数量

现在你有了这些信息，你的营销团队就可以开始针对这些潜在客户进行努力了。

现在我们来看看你可以使用的一些其他选项来解决这个多类分类问题。

探索其他 CREATE MODEL 选项

我们还可以以几种不同的方式创建此模型，我们将在以下章节中探讨。了解可用的不同选项非常重要，这样你就可以进行实验并选择给你带来最佳模型的方案。

在第一个例子中，我们不会提供任何用户指导，例如指定MODEL_TYPE、PROBLEM_TYPE或OBJECTIVE。如果你是机器学习的新手，希望让 SageMaker Autopilot 为你确定这些，请使用这种方法。

然后，在下一个示例中，您可以看到如何提供PROBLEM_TYPE和OBJECTIVE。作为一个更有经验的机器学习用户，您现在应该能够识别出哪些PROBLEM_TYPE和OBJECTIVE实例最适合您的用例。当您提供这些输入时，将加速模型训练过程，因为 SageMaker Autopilot 将仅使用提供的用户指导进行训练。

创建无用户指导的模型

在这种方法中，我们让 SageMaker Autopilot 选择MODEL_TYPE、PROBLEM_TYPE和OBJECTIVE：

CREATE MODEL chapter6_supervisedclassification.cust_segmentation_model
FROM (
SELECT
    id,
    gender,
    ever_married,
    age,
    graduated,
    profession,
    work_experience,
    spending_score,
    family_size,
    var_1,
    segmentation
FROM chapter6_supervisedclassification.cust_segmentation_train
)
TARGET segmentation
FUNCTION predict_cust_segment  IAM_ROLE default
SETTINGS (
  S3_BUCKET '<<your S3 Bucket>>',
  S3_GARBAGE_COLLECT OFF,
  MAX_RUNTIME 9600
);

注意，我们只提供了基本设置。我们没有指定MODEL_TYPE、PROBLEM_TYPE或OBJECTIVE。Amazon Redshift ML 和 SageMaker 将自动确定这是一个多类分类问题，并使用最佳模型类型。作为额外的练习，运行这个CREATE MODEL命令，然后运行SHOW MODEL命令。它将显示 Amazon SageMaker 用于训练模型的MODEL_TYPE参数。

创建具有一些用户指导的模型

在这个示例中，我们将提供PROBLEM_TYPE和OBJECTIVE，但我们将让 Amazon SageMaker 确定MODEL_TYPE：

CREATE MODEL chapter6_supervisedclassification.cust_segmentation_model_ug
FROM (
SELECT
    id,
    gender,
    ever_married,
    age,
    graduated,
    profession,
    work_experience,
    spending_score,
    family_size,
    var_1,
    segmentation
FROM chapter6_supervisedclassification.cust_segmentation_train
)
TARGET segmentation
FUNCTION predict_cust_segment_ug  IAM_ROLE default
PROBLEM_TYPE MULTICLASS_CLASSIFICATION
OBJECTIVE 'accuracy'
SETTINGS (
  S3_BUCKET '<<your S3 Bucket>>',
  S3_GARBAGE_COLLECT OFF,
  MAX_RUNTIME 9600
  );

在这个示例中，我们让 Amazon Redshift ML 和 Amazon SageMaker 确定MODEL_TYPE，并传入PROBLEM_TYPE和OBJECTIVE。当您有空闲时间时，尝试不同的模型创建方法，并注意您在模型训练时间上看到的不同，以及比较SHOW MODEL命令的准确性和其他输出。

您还可以使用 XGBoost 创建多类分类模型，我们将在第十章中介绍。

摘要

在本章中，我们详细讨论了分类模型，并探讨了它们的常见用例。我们还解释了分类模型的CREATE MODEL语法，其中您通过提供模型类型和目标来指导训练模型。

您学习了如何使用 Amazon Redshift ML 进行二分类和多类分类，以及如何使用 XGBoost 和线性学习算法。我们还向您展示了如何检查模型状态，验证其准确性，并编写 SQL 查询在测试数据集上运行预测。

在下一章中，我们将向您展示如何使用 Amazon Redshift ML 构建回归模型。

第七章：构建回归模型

在上一章中，我们学习了关于分类模型的内容。在本章中，我们将学习构建线性回归模型，其中我们预测数值变量。与分类模型不同，线性回归模型用于预测连续数值。与上一章类似，你也将学习 Redshift 提供的创建线性回归模型的多种方法。

本章将提供几个使用这些建模技术的商业问题的详细示例。在本章中，我们将介绍如何尝试不同的算法以获得最佳的回归模型。

到本章结束时，你将能够确定一个商业问题是否是线性回归，然后能够识别 Redshift 提供的正确方法来训练和构建模型。

在本章中，我们将探讨以下主要主题：

• 介绍回归算法

• 使用 XGBoost 算法创建简单的回归模型

• 创建多输入回归模型

技术要求

本章需要网络浏览器和访问以下内容：

• AWS 账户

• Amazon Redshift 无服务器端点

• Amazon Redshift 查询编辑器 v2

你可以在此处找到本章使用的代码：

github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter7/chapter7.sql

介绍回归算法

回归模型用于尝试预测数值结果，例如预测某件商品的售价。结果变量是你的目标，输入变量用于确定变量之间的关系，以便你可以在没有目标变量的数据集上预测未知的目标。

你可以有一个单一输入变量，也称为简单线性回归。例如，工作经验和薪水通常存在关联。

多元线性回归是指你有多个输入变量。例如，通过使用目标（价格）与各种输入（如面积、卧室数量、游泳池、地下室、地块大小和建造年份）之间的关系来预测特定邮编区房屋的售价。

一个好的线性回归模型在直线和数据点之间有很小的垂直距离。请参考以下图示：

图 7.1 – 线性回归线

以下是一些回归模型有用的常见用例：

• 价格和收入预测

• 预测客户终身价值

• 预测天气

• 测量营销活动的有效性

本章将向您展示如何使用 XGBoost 和线性学习器算法在 Amazon Redshift ML 中构建回归模型，这些算法您在第六章中使用过。正如您将看到的，您可以在不同的机器学习问题上使用相同的算法。

我们已经研究了回归问题；现在让我们看看 Redshift 的CREATE MODEL命令来创建回归模型。

带有用户指导的 Redshift 的 CREATE MODEL

当在 Redshift 中使用CREATE MODEL命令时，系统将自动搜索最适合您特定数据集的预处理和模型组合。然而，在某些情况下，您可能希望对模型创建过程有更多的控制，或者希望结合领域特定的知识。

Redshift 提供了灵活性，以指导CREATE MODEL过程，从而减少 AutoML 作业所需的时间。

在本章中，我们将探讨CREATE MODEL语句的模型类型和问题类型参数。作为带有用户指导的CREATE MODEL的一部分，您还可以选择设置预处理程序，但我们将把这个话题留到第十章中。

当您指导 AutoML 作业时，作为机器学习模型创建者，您将决定使用哪种算法以及解决哪种问题类型。Redshift ML 仍然在幕后执行独立变量的特征工程——例如，在 20 个特征中，Redshift ML 将自动识别分类变量和数值变量，并在适用的情况下创建一个热编码值或数值变量的标准化，以及完成模型训练所需的各种其他任务。

总结来说，您让 Redshift ML 处理机器学习的大部分数据准备任务。作为模型创建者，您有选择在CREATE MODEL语句中使用哪种算法和问题类型的选项，这有助于减少训练时间，因为 SageMaker 不需要花费时间确定使用哪种算法或问题类型。

现在我们已经了解了带有用户指导的CREATE MODEL是什么，让我们开始创建一个简单的回归模型。

使用 XGBoost 创建简单的线性回归模型

为了构建我们的简单线性回归问题，我们将查看一个包括根据身高预测体重的数据集。这个数据集只有一个自变量，即英寸中的身高，用于预测磅重的体重。由于只有一个自变量，我们称这个模型为简单线性 回归模型。

在本节中，我们将上传数据，分析它，为训练模型做准备，最后，我们将创建模型并使用模型创建的函数运行预测查询。

上传和分析数据

在本节中，我们将处理身高和体重数据集。

该数据集包含 25,000 名 18 岁参与者的合成身高和体重记录。这些数据基于 1993 年的成长调查，该调查对从出生到 18 岁的 25,000 名儿童进行了调查。参与者来自母婴健康中心（MCHCs）和学校，收集的数据被用于开发香港当前的体重、身高、体重/年龄、体重/身高和体质指数（BMI）的生长曲线。

更多关于此数据集的详细信息可以在以下链接找到：wiki.stat.ucla.edu/socr/index.php/SOCR_Data_Dinov_020108_HeightsWeights。

数据集引用

Hung-Kwan So, Edmund AS Nelson, Albert M Li, Eric MC Wong, Joseph TF Lau, Georgia S Guldan, Kwok-Hang Mak, Youfa Wang, Tai-Fai Fok, 和 Rita YT Sung. (2008) 香港儿童身高、体重和体质指数的长期变化。BMC Public Health. 2008; 8: 320. doi: 10.1186/1471-2458-8-320. PMCID: PMC2572616

Leung SS, Lau JT, Tse LY, Oppenheimer SJ。香港儿童从出生到 18 岁的体重和身高参考值。J Paediatr Child Health. 1996;32:103–109. doi: 10.1111/j.1440-1754.1996.tb00904.x.

Leung SS, Lau JT, Xu YY, Tse LY, Huen KF, Wong GW, Law WY, Yeung VT, Yeung WK, 等人。中国香港人站立身高、坐高和性成熟的长期变化——香港成长研究，1993。Ann Hum Biol. 1996;23:297–306. doi: 10.1080/03014469600004532.

在以下小节中，我们将讨论我们试图使用此数据集实现的预测目标，然后分析数据。

预测目标

目标是根据提供的身高作为数值预测儿童的体重。

该数据集包含以下列：

列	描述
索引	顺序号
英寸高的身高	儿童的身高数值
磅重的体重	儿童的体重数值

表 7.1 – 数据定义

数据分析

在成功连接到 Redshift 作为管理员或数据库开发者后，按照以下步骤创建模式和加载数据到 Amazon Redshift：

1. 导航到Redshift 查询编辑器 v2并连接到无服务器端点，然后连接到dev数据库。

2. 将未命名的查询编辑器保存为Chapter7来命名。

以下截图显示了无服务器连接，数据库设置为Chapter7：

图 7.2 – 连接到无服务器端点

1. 按照以下步骤创建模式：

   create schema chapter7_RegressionModel;
   

2. 使用以下代码创建一个表：

   --create table to load data
   

   DROP TABLE chapter7_RegressionModel.height_weight;
   

   CREATE TABLE chapter7_RegressionModel.height_weight
   

   (
   

       Id integer,
   

       HeightInches decimal(9,2),
   

       weightPounds decimal(9,2)
   

   )
   

   ;
   

3. 使用以下命令加载数据：

   TRUNCATE chapter7_RegressionModel.height_weight;
   

   COPY chapter7_RegressionModel.height_weight
   

   FROM 's3://packt-serverless-ml-redshift/chapter07/heightweight/HeightWeight.csv'
   

   IAM_ROLE default
   

   CSV
   

   IGNOREHEADER 1
   

   REGION AS 'eu-west-1';
   

4. 通过创建直方图来分析身高和体重数据集表。

5. 使用 Query Editor v2 的图表功能创建一个图表。首先，运行以下命令，然后点击结果窗格右侧的图表选项：

   SELECT * FROM
   

   chapter7_RegressionModel.height_weight
   

   ORDER BY 2,3;
   

要生成以下图表，您需要向图表中添加两个轨迹。默认情况下，图表已加载一个轨迹，因此您需要添加一个额外的轨迹。您可以通过点击+ 轨迹按钮来添加它。

以下图表显示了两个变量。对于轨迹 1，在y轴上选择heightinches，将x轴留空。对于轨迹 2，在y轴上选择weightpounds，将x轴留空。生成的图表应该看起来像这样：

图 7.3 – 权重和身高

如您所见，随着身高的增加，权重呈现轻微的上升趋势。

现在我们已经分析了我们的数据集，我们将将其分割成训练集和验证集。训练集将用于训练我们的模型，验证集将用于评估模型的准确性。

将数据分割成训练集和验证集

由于我们只有一个数据集，让我们编写一个查询，将数据分割成两个逻辑集：训练集和验证集。

为了训练模型，让我们使用以下语法where id%8 不等于 0：

SELECT * FROM
chapter7_RegressionModel.height_weight Where id%8!=0;

为了验证模型，让我们使用where id%8 等于 0：

SELECT * FROM
chapter7_RegressionModel.height_weight Where id%8=0;

我们已经分析和准备了我们的输入数据，现在让我们创建一个机器学习模型。

创建一个简单的线性回归模型

在本节中，您将使用带有用户指导的CREATE MODEL来创建一个简单的线性回归模型，使用 XGBoost 算法。我们将通过训练机器学习模型来解决重量预测问题。该模型的目标是根据给定的高度预测重量。

我们将MODEL_TYPE设置为xgboost，将PROBLEM_TYPE设置为regression。我们将其他选项保留为默认值：

DROP MODEL chapter7_RegressionModel.predict_weight;
CREATE MODEL chapter7_RegressionModel.predict_weight
FROM (select heightinches, cast(round(weightpounds,0) as integer) weightpounds from chapter7_RegressionModel.height_weight where id%8!=0 )
TARGET weightpounds
FUNCTION predict_weight
IAM_ROLE default
MODEL_TYPE xgboost
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (s3_bucket '<<your-S3-bucket>>',
          s3_garbage_collect off,
          max_runtime 3600);

让我们看看我们在CREATE MODEL语句中提供的选项，并讨论它们如何影响 Amazon SageMaker 采取的行动。

在CREATE MODEL语句中，我们通过设置MODEL_TYPE来指导 Redshift ML 使用 XGBoost 算法。Amazon SageMaker Autopilot 作业不会使用其他支持的算法来训练模型 – 例如，线性学习器或多层感知器（MLP）。当此选项保留为默认值时，Amazon SageMaker 将使用 Autopilot 支持的所有算法来训练模型。

接下来，当我们把PROBLEM_TYPE设置为regression时，我们正在指导 Redshift ML 寻找一个模型来解决回归问题类型。

我们将OBJECTIVE设置为mse（均方误差），这是评估回归模型性能的常用方法。它是预测值与实际值之间平方差的平均值。

通过这三个指导选项，我们正在为 Amazon SageMaker Autopilot 创建边界。最终结果将是更少的训练时间，并附带 Autopilot 算法的其他好处——例如，调整超参数和数据预处理步骤，这些都是由 Amazon SageMaker Autopilot 自动处理的。

要检查模型的状态，请运行以下命令：

SHOW MODEL chapter7_RegressionModel.predict_weight;

以下屏幕截图显示了SHOW MODEL命令的输出：

图 7.4 – 显示模型输出

模型仍在训练中，但您会注意到 Redshift ML 正在获取CREATE MODEL语句。

predict_weight用于生成预测，并在SELECT语句中使用，我们将在下一节中介绍。

在一段时间后再次运行SHOW MODEL命令，以检查模型训练是否完成。从下面的屏幕截图可以看出，模型训练已完成，MSE 已被选为模型评估的目标。这是由 Redshift ML 自动选择的，是线性回归模型的正确评估方法：

图 7.5 – 显示模型输出 – 模型就绪状态

我们已经训练并创建了模型；在下一步，我们将生成预测。

运行预测

由于我们的模型已经成功训练，让我们对未见过的数据集进行一些预测。

运行以下查询以找到模型精确预测英寸身高对应的磅体重记录，其中id%8=0。通过使用WHERE id%8=0，我们正在查看约 20%的数据集。这些是未包含在模型训练中的记录。如果您还记得，在CREATE MODEL语句中，我们指定了WHERE id%8 !=0：

SELECT heightinches, CAST(chapter7_RegressionModel.predict_weight(CAST(ROUND(heightinches,0) as integer)) as INTEGER) as Predicted_Weightpounds,
  CAST(ROUND(weightpounds,0) as INTEGER) Original_Weightpounds ,
  Predicted_Weightpounds - Original_Weightpounds  as Difference
  FROM chapter7_RegressionModel.height_weight WHERE id%8=0
  AND Predicted_Weightpounds - Original_Weightpounds = 0;

下面是输出结果：

图 7.6 – 显示预测体重结果

现在，让我们检查 MSE 和均方根 误差（RMSE）：

  SELECT
   ROUND(AVG(POWER(( Original_Weightpounds - Predicted_Weightpounds ),2)),2) mse
    , ROUND(SQRT(AVG(POWER(( Original_Weightpounds - Predicted_Weightpounds ),2))),2) rmse
FROM
    ( select heightinches, cast(chapter7_RegressionModel.predict_weight(cast(round(heightinches,0) as integer)) as integer) as Predicted_Weightpounds,
  cast(round(weightpounds,0) as integer) Original_Weightpounds ,
  Predicted_Weightpounds - Original_Weightpounds as Difference
  from chapter7_RegressionModel.height_weight where id%8=0
);

下面是输出结果：

图 7.7 – MSE 和 RMSE 值

我们的多项式误差平方和（MSE）值较高；它代表可能存在异常值或我们没有足够变量的数据。例如，添加年龄和性别可能会提高预测分数。

让我们在折线图中比较预测分数和原始分数：

 select heightinches, cast(chapter7_RegressionModel.predict_weight(cast(round(heightinches,0) as integer)) as integer) as Predicted_Weightpounds,
  cast(round(weightpounds,0) as integer) Original_Weightpounds ,
  Predicted_Weightpounds - Original_Weightpounds as Difference
  from chapter7_RegressionModel.height_weight where id%8=0;

一旦返回响应，请点击查询编辑器右侧的图表选项，为折线图添加一个轨迹，并选择预测 _ 体重 _ 磅。为折线图添加另一个轨迹并选择原始 _ 体重 _ 磅，然后添加第三个轨迹，但这次选择条形图并添加差异列。

在下面的图表中，您将注意到预测分数正在遵循原始分数。差异显示在图表底部，它提供了关于方差或误差的信息：

图 7.8 – 预测值与原始权重对比

我们已经学习了如何使用 Redshift ML 创建简单的回归模型。现在让我们来了解多输入回归模型。

创建多输入回归模型

在这个练习中，你将学习如何在 Amazon Redshift ML 中使用多个输入变量构建回归模型。

您的任务是构建和训练一个模型，以预测即将举行的活动收入，以便主动采取措施增加门票销售，确保收入数字达到公司的目标。

在成功连接到 Redshift 作为管理员或数据库开发者后，将数据加载到 Amazon Redshift。

导航到Redshift 查询编辑器 v2并连接到无服务器端点和dev数据库。

使用您为上一个练习创建的相同架构和查询编辑器页面。

使用以下 SQL 命令创建您的输入表并加载数据：

CREATE TABLE chapter7_RegressionModel.sporting_event_ticket_info (
ticket_id double precision ,
event_id bigint,
sport character varying(500),
event_date_time timestamp without time zone,
home_team character varying(500),
away_team character varying(500),
location character varying(500),
city character varying(500),
seat_level bigint,
seat_section bigint,
seat_row character varying(500),
seat bigint ENCODE az64,
list_ticket_price double precision,
final_ticket_price double precision ,
ticketholder character varying(500)
)
DISTSTYLE AUTO;
COPY chapter7_RegressionModel.sporting_event_ticket_info
FROM 's3://packt-serverless-ml-redshift/chapter07/ticket_info'
IAM_ROLE default
FORMAT AS CSV DELIMITER ',' QUOTE '"'
REGION AS 'eu-west-1';

让我们分析我们的数据集，并获取过去几个月的票务销售历史趋势：

Select extract(month from event_date_time) as month,
sum(cast (final_ticket_price as decimal(8,2))) as ticket_revenue
From chapter7_RegressionModel.sporting_event_ticket_info
where event_date_time < '2019-10-27'
group by 1
order by 1;

输出如下：

图 7.9 – 按月计算的票务收入

我们可以看到，在7月和8月，销售额呈现出峰值并急剧下降。让我们创建一个模型，以便我们可以预测那些将会有较低门票收入的团队。在创建我们的模型之前，我们需要将数据集分别划分为训练集、验证集和测试集。

1. 在查询编辑器 v2 中执行以下代码以创建 training 表：

   CREATE TABLE chapter7_RegressionModel.sporting_event_ticket_info_training (
   

       ticket_id double precision ,
   

       event_id bigint,
   

       sport character varying(500),
   

       event_date_time timestamp without time zone,
   

       home_team character varying(500),
   

       away_team character varying(500),
   

       location character varying(500),
   

       city character varying(500),
   

       seat_level bigint,
   

       seat_section bigint,
   

       seat_row character varying(500),
   

       seat bigint ENCODE az64,
   

       list_ticket_price double precision,
   

       final_ticket_price double precision ,
   

       ticketholder character varying(500)
   

   )
   

   DISTSTYLE AUTO;
   

2. 下一步是将 ~70% 的数据插入到 训练 表中：

   --insert ~70% of data into training_set
   

   insert into   chapter7_RegressionModel.sporting_event_ticket_info_training
   

   (  ticket_id ,event_id ,sport , event_date_time,  home_team , away_team , location , city , seat_level, seat_section,
   

       seat_row ,  seat, list_ticket_price, final_ticket_price, ticketholder )
   

    select
   

    ticket_id ,event_id ,sport , event_date_time,  home_team , away_team , location , city , seat_level, seat_section,
   

       seat_row ,  seat, list_ticket_price, final_ticket_price, ticketholder
   

    from chapter7_RegressionModel.sporting_event_ticket_info
   

    where event_date_time < '2019-10-20';
   

3. 接下来，你将创建验证表：

   CREATE TABLE chapter7_RegressionModel.sporting_event_ticket_info_validation (
   

       ticket_id double precision ,
   

       event_id bigint,
   

       sport character varying(500),
   

       event_date_time timestamp without time zone,
   

       home_team character varying(500),
   

       away_team character varying(500),
   

       location character varying(500),
   

       city character varying(500),
   

       seat_level bigint,
   

       seat_section bigint,
   

       seat_row character varying(500),
   

       seat bigint ENCODE az64,
   

       list_ticket_price double precision,
   

       final_ticket_price double precision ,
   

       ticketholder character varying(500)
   

   )
   

   DISTSTYLE AUTO;
   

4. 接下来，将 ~10% 的数据插入到 验证 表中：

   insert into  chapter7_RegressionModel.sporting_event_ticket_info_validation
   

   (  ticket_id ,event_id ,sport , event_date_time,  home_team , away_team , location , city , seat_level, seat_section,
   

       seat_row ,  seat, list_ticket_price, final_ticket_price, ticketholder )
   

    select
   

    ticket_id ,event_id ,sport , event_date_time,  home_team , away_team , location , city , seat_level, seat_section,
   

       seat_row ,  seat, list_ticket_price, final_ticket_price, ticketholder
   

    from chapter7_RegressionModel.sporting_event_ticket_info
   

    where event_date_time between '2019-10-20' and '2019-10-22' ;
   

5. 最后，创建测试表：

   CREATE TABLE chapter7_RegressionModel.sporting_event_ticket_info_testing (
   

       ticket_id double precision ,
   

       event_id bigint,
   

       sport character varying(500),
   

       event_date_time timestamp without time zone,
   

       home_team character varying(500),
   

       away_team character varying(500),
   

       location character varying(500),
   

       city character varying(500),
   

       seat_level bigint,
   

       seat_section bigint,
   

       seat_row character varying(500),
   

       seat bigint ENCODE az64,
   

       list_ticket_price double precision,
   

       final_ticket_price double precision ,
   

       ticketholder character varying(500)
   

   )
   

   DISTSTYLE AUTO;
   

6. 接下来，将 ~20% 的数据插入到 testing 表中：

   insert into   chapter7_RegressionModel.sporting_event_ticket_info_testing
   

   (  ticket_id ,event_id ,sport , event_date_time,  home_team , away_team , location , city , seat_level, seat_section,
   

       seat_row ,  seat, list_ticket_price, final_ticket_price, ticketholder )
   

   select
   

    ticket_id ,event_id ,sport , event_date_time,  home_team , away_team , location , city , seat_level, seat_section,
   

       seat_row ,  seat, list_ticket_price, final_ticket_price, ticketholder
   

    from chapter7_RegressionModel.sporting_event_ticket_info
   

    where event_date_time >  '2019-10-22'
   

    ;
   

我们已经准备好了用于训练和测试机器学习模型的数据库；现在让我们使用线性学习器算法创建一个回归模型。

线性学习算法

如我们在第六章中看到的，您可以使用线性学习器模型类型来解决分类或回归问题。这是一个监督学习算法。对于回归问题，我们试图预测一个数值结果，在这个练习中，我们将使用多个输入；SageMaker 将根据连续目标使用均方误差（MSE）来选择最佳模式。

我们提供了一个包含我们的输入或关于数据的观察以及标签的训练集，标签代表我们想要预测的值。我们的目标是准确预测未来的票务销售。

我们将 MODEL_TYPE 设置为 LINEAR_LEARNER，PROBLEM_TYPE 设置为 regression，OBJECTIVE 设置为 mse。我们保留其他选项为默认值。

在查询编辑器 v2 中执行此代码以训练模型。请确保使用你之前创建的存储桶替换以下 S3 桶。你需要输入你之前创建的 S3 桶来存储 Redshift ML 工件。

运行以下命令来训练回归模型：

CREATE MODEL chapter7_RegressionModel.predict_ticket_price_linlearn from
chapter7_RegressionModel.sporting_event_ticket_info_training
TARGET final_ticket_price
FUNCTION predict_ticket_price_linlearn
IAM_ROLE default
MODEL_TYPE LINEAR_LEARNER
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (s3_bucket '<<your-S3-Bucket>>',
s3_garbage_collect off,
max_runtime 9600);

一旦模型状态为 READY，你就可以继续了。要检查模型状态，请运行以下命令：

SHOW MODEL chapter7_RegressionModel.predict_ticket_price_linlearn;

注意你看到的 MSE 分数；它将与 图 7.10 中的输出相似：

图 7.10 – SHOW MODEL 输出

我们现在已经创建了机器学习模型；让我们验证其性能。

理解模型评估

你通过 MSE 和/或 RMSE 来衡量回归问题的模型性能。这是预测数值目标和实际数值答案之间的距离，也称为 SHOW MODEL 输出，我们看到 MSE。我们也可以通过平方实际值和预测值之间的差异然后取平均值来自己计算这个值。然后，取 MSE 的平方根得到 RMSE。MSE 和 RMSE 分数越低，表示越好。

如我们从 SHOW MODEL 输出中看到，我们的 MSE 分数超过 681 - 让我们通过运行以下 SQL 命令来检查这个和 RMSE 分数与我们的验证：

SELECT
      ROUND(AVG(POWER(( actual_price_revenue - predicted_price_revenue ),2)),2) mse
    , ROUND(SQRT(AVG(POWER(( actual_price_revenue - predicted_price_revenue ),2))),2) rmse
FROM
    (select home_team, chapter7_RegressionModel.predict_ticket_price_linlearn (ticket_id, event_id, sport, event_date_time, home_team, away_team,
Location, city, seat_level, seat_section, seat_row, seat,
list_ticket_price ,ticketholder ) as predicted_price_revenue,
 final_ticket_price  as actual_price_revenue
From chapter7_RegressionModel.sporting_event_ticket_info_validation
     );

这是查询的输出：

图 7.11 – MSE 和 RMSE 值

虽然 MSE 分数似乎有点高，我们也可以运行一个验证查询来检查我们的准确率。你会在下面的查询中注意到它使用了由我们的 CREATE MODEL 命令生成的函数来获取预测价格收入，以便与我们比较实际价格收入：

Select home_team,
sum(cast(chapter7_RegressionModel.predict_ticket_price_linlearn (ticket_id, event_id, sport,
event_date_time, home_team, away_team,
Location, city, seat_level, seat_section, seat_row, seat,
list_ticket_price ,ticketholder ) as decimal(8,2) )) as predicted_price_revenue,
sum(cast (final_ticket_price as decimal(8,2))) as actual_price_revenue,
(predicted_price_revenue - actual_price_revenue) as diff,
abs((predicted_price_revenue - actual_price_revenue)/actual_price_revenue) * 100  as pct_diff
From chapter7_RegressionModel.sporting_event_ticket_info_validation
group by 1
order by 5 desc ;

这是查询的输出：

图 7.12 – 预测价格与实际价格

观察结果，模型的表现不如我们期望。你可以运行验证查询来查看训练数据，你会发现模型在训练数据上的表现也不太好——这被称为欠拟合。

一个解决方案是添加更多特征，但我们已经使用了所有可用的特征。

让我们再次运行模型，但这次我们将使用 auto 选项，让 SageMaker 选择算法：

CREATE MODEL Chapter7_RegressionModel.predict_ticket_price_auto
from
chapter7_RegressionModel.sporting_event_ticket_info_training
TARGET final_ticket_price
FUNCTION predict_ticket_price_auto
IAM_ROLE default
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (s3_bucket '<<your-S3-bucket>>',
s3_garbage_collect off,
max_runtime 9600);

在让模型训练一段时间后，按照以下方式检查模型的状态：

SHOW MODEL Chapter7_RegressionModel.predict_ticket_price_auto;

这是它的样子：

图 7.13 – SHOW MODEL 输出

从前面的图中，我们看到两个突出的事情：

• MSE 分数要好得多

• Amazon SageMaker 选择使用 XGBoost 算法

我们可以使用验证数据集来检查我们新模型的 MSE 和 RMSE 分数，如下所示：

SELECT
      ROUND(AVG(POWER(( actual_price_revenue - predicted_price_revenue ),2)),2) mse
    , ROUND(SQRT(AVG(POWER(( actual_price_revenue - predicted_price_revenue ),2))),2) rmse
FROM
    (select home_team, chapter7_RegressionModel.predict_ticket_price_auto (ticket_id, event_id, sport, event_date_time, home_team, away_team,
Location, city, seat_level, seat_section, seat_row, seat,
list_ticket_price ,ticketholder ) as predicted_price_revenue,
 final_ticket_price  as actual_price_revenue
From chapter7_RegressionModel.sporting_event_ticket_info_validation
     );

这是输出：

图 7.14 – MSE 和 RMSE 分数

这些 MSE 和 RMSE 值表明我们有一个很好的模型。

让我们使用新模型的predict_ticket_price_auto函数运行一个验证查询：

Select home_team,
sum(cast(chapter7_RegressionModel.predict_ticket_price_auto (ticket_id, event_id, sport, event_date_time, home_team, away_team,
Location, city, seat_level, seat_section, seat_row, seat,
list_ticket_price ,ticketholder ) as decimal(8,2) )) as predicted_price_revenue,
sum(cast (final_ticket_price as decimal(8,2))) as actual_price_revenue,
(predicted_price_revenue - actual_price_revenue) as diff,
((predicted_price_revenue - actual_price_revenue)/actual_price_revenue) * 100  as pct_diff
From chapter7_RegressionModel.sporting_event_ticket_info_validation
group by 1
order by 5 desc;

以下是该查询的输出：

图 7.15 – 预测价格与实际价格对比

您可以看到，当我们比较实际票价收入与预测票价收入之间的差异时，我们得到了更好的结果。我们将使用这个模型来进行我们的预测查询。

运行以下查询以查看哪些输入对模型预测贡献最大：

set search_path to chapter7_regressionmodel;
select json_table.report.explanations.kernel_shap.label0.global_shap_values from
 (select explain_model('predict_ticket_price_auto') as report) as json_table

为了使结果集更容易阅读，右键单击结果集并选择复制行。然后您可以将它粘贴到如图图 7.16所示的编辑器中：

图 7.16 – 模型可解释性报告

这表明list_ticket_price贡献了最大的权重，而sport贡献了最小的权重。

我们已经使用验证数据集验证了模型，检查了 MSE 值，并确定了特征重要性。现在让我们在测试数据上运行预测查询。

预测查询

现在我们有了模型并完成了验证，我们可以运行我们的预测查询以测试数据集，以确定哪些团队和活动需要采取主动措施来增加票务销售。让我们检查预测收入低于 20 万的团队：

select t1.home_team, predicted_price_revenue
from
(Select home_team,
sum(cast(chapter7_RegressionModel.predict_ticket_price_auto (ticket_id, event_id, sport, event_date_time, home_team, away_team,
Location, city, seat_level, seat_section, seat_row, seat,
list_ticket_price ,ticketholder ) as decimal (8,2) ) ) as predicted_price_revenue
From chapter7_RegressionModel.sporting_event_ticket_info_testing
group by 1) t1
where predicted_price_revenue < 200000;

这是结果：

图 7.17 – 预测价格与测试数据集对比

有 16 个团队预测将减少票务收入。您可以与您的营销团队分享此信息，以创建一个专注的战略，确保票务收入可以保持稳定。

摘要

在本章中，我们详细讨论了回归模型，并了解了如何创建单输入和多输入回归模型。我们学习了如何轻松预测数值。我们还学习了如何验证回归模型，采取行动提高我们模型的准确性，并使用回归模型进行预测查询。我们探讨了使用 XGBoost、线性学习者和auto选项来训练模型的选择。

我们还了解了如何使用 Redshift 中的 SQL 命令从SHOW MODEL输出中检查和验证 MSE 分数。

在下一章中，我们将向您展示如何使用 K-means 算法创建无监督模型。

第八章：使用 K-Means 聚类构建无监督模型

到目前为止，我们已经学习了关于构建带有标签数据的机器学习模型（ML）。在本章中，我们将学习如何使用K-means 聚类算法在没有任何标签的数据集上构建机器学习模型。与监督模型不同，监督模型在观察层面进行预测，而 K-means 聚类将观察结果分组到具有共同特征的簇中——例如，相似的人口统计或阅读习惯。

本章将提供使用这些建模技术的详细业务问题示例。到本章结束时，您将能够识别一个可以应用无监督建模技术的业务问题。您还将学习如何构建、训练和评估 K-means 模型的性能。

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

• 通过聚类分析分组数据

• 创建 K-means 机器学习模型

• 评估 K-means 聚类结果

技术要求

本章需要使用网络浏览器并访问以下内容：

• AWS 账户

• Amazon Redshift 无服务器端点

• Amazon Redshift 查询编辑器 v2

• 完成第一章中的“Amazon Redshift 无服务器入门”部分

您可以在以下链接找到本章使用的代码：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter8/chapter8.sql.

通过聚类分析分组数据

到目前为止，我们已经探讨了包含输入和目标变量的数据集，并使用一组输入变量和目标变量训练了一个模型。这被称为监督学习。然而，如何处理不包含标签以监督训练的数据集呢？Amazon Redshift ML 支持使用聚类分析方法进行无监督学习，也称为 K-means 算法。在聚类分析中，机器学习算法自动发现数据点的分组。例如，如果您有 1,000 人的群体，聚类算法可以根据身高、体重或年龄将他们分组。

与监督学习不同，监督学习中的机器学习模型基于标签预测结果，无监督模型使用未标记的数据。无监督学习的一种类型是聚类，其中未标记数据根据其相似性或差异分组。从关于个人人口统计信息的数据集中，你可以根据年轻、成年和老年人口，体重过轻、正常体重和超重人口等创建聚类。这些群体基于值计算——例如，如果两个人都是年轻人，那么他们会被分到一组。这些群体被称为聚类。在下面的图中，你可以看到输入变量（年龄、身高和体重）被分组到年轻、成年和老年：

图 8.1 – 一个简单的聚类示例

在前面的图中，每个数据点根据其到聚类中心的距离被放置在聚类中，这个距离称为质心。每个数据点到质心的距离使用欧几里得距离公式计算。距离给定质心最近的数据点具有相似性，属于同一组。在现实世界中，经常遇到具有重叠聚类和大量数据点的情况。当你遇到过多的聚类时，确定数据集的正确聚类数量就成了一项挑战。

K-means 聚类的常见用例包括以下内容：

• 电子商务：根据购买历史分组客户

• 医疗保健：检测疾病模式

• 金融：将购买行为分为异常和正常

接下来，我们将向您展示一种常见的方法，帮助您确定应该使用多少个聚类。

确定最佳聚类数量

一种常用的方法是肘部方法。肘部方法的想法是运行具有不同 K 值的 K-means 算法——例如，从 1 个聚类到 10 个聚类——并为每个 K 值计算平方误差之和。然后，绘制平方偏差之和（SSD）值的图表。SSD 是平方差的和，用于衡量方差。如果折线图看起来像一条臂，那么臂上的肘部就是各种 K 值中最佳的 K 值。这种方法背后的原理是，SSD 通常随着 K 值的增加而减少，而评估方法的目的是追求更低的 SSD 或均方偏差（MSD）值。肘部代表一个起点，当 K 值增加时，SSD 开始减少回报。

在下面的图表中，你可以看到当 MSD 值在不同 K 值上绘制时，代表一条臂，而肘部在值6处。在6之后，MSD 值没有显著下降，因此我们可以选择6作为以下场景中最佳的聚类值：

图 8.2 – 在不同的 K 值上绘制 MSD 值

接下来，让我们看看如何使用 Amazon Redshift ML 创建 K-means 聚类模型。

创建 K-means 机器学习模型

在本节中，我们将通过一个用例来介绍这个过程。在这个用例中，假设您是一家专注于家居改善商品的电子商务公司的数据分析师。您被要求根据收入对不同地区的经济部门进行分类，以便您可以更好地根据各种因素，如中位房价，来定位客户。我们将使用 Kaggle 上的此数据集：www.kaggle.com/datasets/camnugent/california-housing-prices。

从这个数据集中，您将使用 median_income、latitude 和 longitude 属性，以便可以根据 location 和 income 创建聚类。

创建 K-means 模型的语法与您迄今为止所使用的语法略有不同，所以让我们深入探讨一下。

创建 K-means 聚类模型的语法概述

创建 K-means 模型的基本语法如下：

CREATE model model_name
FROM (Select_statement)
FUNCTION  function_name
IAM_ROLE default
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS (StandardScaler', 'MinMax', 'NumericPassthrough')
HYPERPARAMETERS DEFAULT EXCEPT (K '2')
SETTINGS (S3_BUCKET 'bucket name');

在前面的代码片段中，有几个要点需要注意，它们以粗体显示，因为它们在创建 K-means 模型时是必需的：

• AUTO OFF：由于不使用 Amazon SageMaker Autopilot，因此必须关闭此选项

• MODEL_TYPE KMEANS：您必须设置 MODEL_TYPE，因为 K-means 没有自动发现功能。

• HYPERPARAMETERS DEFAULT EXCEPT (K '2')：这告诉 SageMaker 在此模型中创建多少个聚类

此外，请注意，K-means 有三个可选的预处理程序可用。我们将在创建模型时更详细地探讨这一点。

您可以参考此链接以获取有关可用 K-means 参数的更多详细信息：docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_k-means-create-model-parameters。

现在，我们将加载数据集，为创建模型做准备。

上传和分析数据

对于此用例，我们将使用一个包含房价信息和基于人口普查数据的摘要统计信息的文件。

注意

数据存储在以下 S3 位置：s3://packt-serverless-ml-redshift/chapter08/housinghousing_prices.csv。

在成功连接到 Redshift 作为管理员或数据库开发者后，将数据加载到 Amazon Redshift 并遵循此处概述的步骤。

1. 导航到 Redshift 查询编辑器 v2，连接到 Serverless: default 端点，然后连接到 dev 数据库。

图 8.3 – 通过 Redshift 查询编辑器 v2 连接

1. 执行以下步骤以创建架构和客户表并加载数据：

   create schema chapter8_kmeans_clustering;
   

   create table chapter8_kmeans_clustering.housing_prices (
   

       longitude decimal(10,2),
   

       latitude decimal(10,2),
   

       housing_median_age integer,
   

       total_rooms integer,
   

       total_bedrooms integer,
   

       population integer,
   

       households integer,
   

       median_income decimal(10,6),
   

       median_house_value integer,
   

       ocean_proximity character varying (50)
   

   )
   

   diststyle auto;
   

   copy chapter8_kmeans_clustering.housing_prices from 's3://packt-serverless-ml-redshift/chapter08/kmeans/housing_prices.csv'
   

   iam_role default format as csv delimiter ',' quote '"' ignoreheader 1 region as 'eu-west-1';
   

此数据集包含 2,064,020,640 条记录。我们将在模型中使用 longitude、latitude 和 median_income。

1. 运行以下查询以检查一些样本数据：

   select * from chapter8_kmeans_clustering.housing_prices
   

   limit 10;
   

你应该得到以下结果：

图 8.4 – 房价数据

现在数据已加载，我们准备创建模型。

创建 K-means 模型

让我们根据 median_income、longitude 和 latitude 创建我们的模型和聚类。

我们将创建一些模型，然后使用肘部方法来确定最佳聚类数量。

首先，让我们使用以下 SQL 创建我们的第一个模型，包含两个聚类。然后，你可以通过改变 K 值来创建不同的模型进行实验，并了解 MSD 值在不同 K 值下的减少情况。

使用 K 值为 2 创建两个聚类

让我们在查询编辑器 v2 中运行以下 SQL 以创建具有两个聚类的模型：

create model chapter8_kmeans_clustering.housing_segments_k2
from(select
            median_income,
            latitude,
            longitude
from chapter8_kmeans_clustering.housing_prices)
function  get_housing_segment_k2
iam_role default
auto off
model_type kmeans
preprocessors '[
      {
        "columnset": [ "median_income", "latitude","longitude" ],
        "transformers": [ "standardscaler" ]
      }
    ]'
hyperparameters default except (k '2')
settings (s3_bucket '<your s3 bucket>');

你可以在这个模型中看到我们为 preprocessors 参数提供了值。我们选择这样做是因为 K-means 对尺度敏感，因此我们可以使用 standardscaler 转换器进行归一化。standardscalar 将均值和尺度移动到单位方差。

hyperparameters 参数是我们指定 (K '2') 来创建两个聚类的位置。请记住添加你的 S3 存储桶，其中存储了创建的模型工件。你将在 s3: s3://<your-s3-bucket>/redshift-ml/housing_segments_k2/ 中找到模型工件。Redshift ML 将自动将 'redshift-ml'/'your model name' 添加到你的 S3 存储桶。现在，使用查询编辑器 v2 中的 SHOW MODEL 命令检查模型的状态：

SHOW MODEL chapter8_kmeans_clustering.housing_segments_k2;

你将看到以下输出：

图 8.5 – 两个聚类

需要注意的关键点是 模型状态，它表示模型已准备好，以及 train:msd，这是目标指标。这代表我们输入数据集中每个记录与模型最近中心的平均平方距离。MSD 值为 1.088200，这是一个不错的分数。

让我们运行一个查询以获取每个聚类中的数据点数量：

  select chapter8_kmeans_clustering.get_housing_segment_k2 (median_income, latitude, longitude) as cluster, count(*) as count from FROM chapter8_kmeans_clustering.housing_prices group byGROUP BY 1 order byORDER BY 1;

输出如下：

图 8.6 – 数据点

聚类从 0 到 n 编号。我们的第一个聚类有 8719 个数据点，第二个聚类有 11921 个数据点。

在我们的用例中，我们希望进一步细分我们的客户。让我们创建一些具有不同聚类数量的更多模型。然后，我们可以评估所有 SSD 值，并应用肘部方法来帮助我们选择用于分析的最佳聚类数量。

使用 K 值为 3 创建三个聚类

让我们在查询编辑器 v2 中运行以下 SQL 以创建具有三个聚类的模型：

CREATE model chapter8_kmeans_clustering.housing_segments_k3
FROM(Select
            median_income,
            latitude,
            longitude
From chapter8_kmeans_clustering.housing_prices)
FUNCTION  get_housing_segment_k3
IAM_ROLE default
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS '[
      {
        "ColumnSet": [ "median_income", "latitude","longitude" ],
        "Transformers": [ "StandardScaler" ]
      }
    ]'
HYPERPARAMETERS DEFAULT EXCEPT (K '3')
SETTINGS (S3_BUCKET '<your s3 bucket>');

创建剩余的模型，包含 4、5 和 6 个聚类

将前面的代码重复 3 次以创建具有 4、5 和 6 个簇的模型。你可以在 github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter8/chapter8.sql 找到代码。

所有模型完成训练将需要大约 15 分钟。然后，运行 SHOW MODEL 命令，包括 K = 2 的模型，如图所示：

SHOW MODEL chapter8_kmeans_clustering.housing_segments_k2;
SHOW MODEL chapter8_kmeans_clustering.housing_segments_k3;
SHOW MODEL chapter8_kmeans_clustering.housing_segments_k4;
SHOW MODEL chapter8_kmeans_clustering.housing_segments_k5;
SHOW MODEL chapter8_kmeans_clustering.housing_segments_k6;

现在，让我们找到“肘部”吧！

收集输入以绘制“肘部”

现在，从每个 SHOW MODEL 命令的输出中，注意 test:msd 的值，并构建一个 Select 语句，如下面的代码片段所示。使用每个模型的 test:mds 值更改 MSD 的值。

例如，我们将使用之前看到的 train:msd 的值 1.088200，用于两个簇的模型。

我们从 SHOW MODEL 输出的 train:mds 的其他输出如下：

• 两个簇：train:msd – 1.088200

• 三个簇：train:msd – 0.775993

• 四个簇：train:msd – 0.532355

• 五个簇：train:msd – 0.437294

• 六个簇：train:msd – 0.373781

注意，你的数字可能略有不同：

Select 2 as K, 1.088200  as MSD
Union
Select 3 as K,  0.775993 as MSD
Union
Select 4 as K,  0.532355 as MSD
Union
Select 5 as K,  0.437294 as MSD
Union
Select 6 as K,  0.373781 as MSD;

在查询编辑器 v2 中运行前面的 SQL 命令。

通过观察输出，我们可以看到 MSD 值在两个簇中最高，随着簇数量的增加而逐渐降低：

图 8.7 – msd

在 结果 窗口中，点击 图表 选项，如图所示：

图 8.8 – 创建图表

通过选择 k 作为 X 值，msd 作为 Y 值，你将得到以下输出：

图 8.9 – 肘部方法图表

从图表中，我们可以看到当 MSD 在折线图上绘制时，形成了一个臂，肘部在 3。这意味着与 3 个簇相比，4 个簇的 MSD 值差异很小。我们可以看到在 3 之后，曲线非常平滑，与线开始时的 MSD 值差异没有剧烈变化。

让我们看看当我们使用为我们的模型部署的函数进行聚类时，数据点是如何聚类的：

select chapter8_kmeans_clustering.get_housing_segment_k3 (median_income, latitude, longitude) as cluster, count(*) as count from chapter8_kmeans_clustering.housing_prices group by 1 order by 1;

我们可以从查询编辑器 v2 中看到以下输出。计数表示分配给每个簇的数据点数量：

图 8.10 – 三个簇

我们也可以通过点击 图表 按钮并观察可视化的簇计数来绘制这个图表：

图 8.11 – 簇数据点

现在，让我们看看我们如何使用我们的模型来帮助基于簇做出业务决策。

评估 K-means 聚类结果

现在您已经使用 K-means 算法对聚类进行了分割，您就可以使用您创建的模型进行各种分析了。

这里是一个您可以运行的示例查询，用于按聚类获取平均中位数房屋价值：

select avg(median_house_value) as avg_median_house_value,
chapter8_kmeans_clustering
.get_housing_segment_k3(median_income, latitude, longitude) as cluster
from chapter8_kmeans_clustering
.housing_prices
group by 2
order by 1;

输出将类似于以下内容：

图 8.12 – 平均中位数房屋价值

您也可以运行一个查询来查看较高的中位数收入是否与具有较高房屋价值的相同聚类相对应。运行以下查询：

select avg(median_income) as median_income,
chapter8_kmeans_clustering.get_housing_segment_k3(
    median_income, latitude, longitude) as cluster
from chapter8_kmeans_clustering.housing_prices
group by 2
order by 1;

输出将类似于以下内容：

图 8.13 – 中位数收入

当我们建立用例时，我们说这是针对一个专注于家居改善产品的电子商务零售商。您还可以使用这些信息创建不同的营销活动，并根据给定聚类的房屋价值定制您的产品。

摘要

在本章中，我们讨论了如何使用 K-means 算法进行无监督学习。

现在，您能够解释 K-means 算法是什么以及它适用于哪些用例。您还可以使用 Amazon Redshift ML 创建 K-means 模型，确定合适的聚类数量，并通过分析聚类得出结论，以帮助做出商业决策。

在下一章中，我们将向您展示如何使用多层感知器算法使用 Amazon Redshift ML 进行深度学习。

第三部分：使用 Redshift ML 部署模型

第三部分 介绍了更多利用 Amazon Redshift ML 的方式。您将了解深度学习算法，如何训练自定义模型，以及如何使用在 Amazon Redshift 之外训练的模型在您的数据仓库中运行推理查询。

本部分以时间序列预测的介绍结束，包括如何使用 Amazon Redshift ML，以及如何优化和轻松重新训练您的模型。

本部分包括以下章节：

• 第九章，使用 Redshift ML 进行深度学习

• 第十章，使用 XGBoost 创建自定义机器学习模型

• 第十一章，在数据库推理中使用您自己的模型

• 第十二章，在您的数据仓库中进行时间序列预测

• 第十三章，实施和优化 Amazon Redshift ML 模型

第九章：使用 Redshift ML 进行深度学习

我们在第六章和第七章中探讨了监督学习，在第八章中探讨了无监督学习模型。在本章中，我们将探讨深度学习算法，一个多层感知器（MLP），它是一个前馈人工神经网络（ANN），并了解它如何处理非线性可分的数据（这意味着你的数据点不能通过一条清晰的线分离）。本章将提供如何在 Amazon Redshift ML 中使用 MLP 进行深度学习的详细步骤。到本章结束时，你将能够识别出可以使用 MLP 解决的问题，并了解如何创建模型、评估模型性能以及运行预测。

在本章中，我们将探讨以下主要主题：

• 深度学习简介

• 商业问题

• 上传和分析数据

• 使用 MLP 创建多类分类模型

• 运行预测

技术要求

本章需要网络浏览器以及访问以下内容：

• AWS 账户

• Amazon Redshift 无服务器端点

• Amazon Redshift 查询编辑器 v2

你可以在此处找到本章使用的代码：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter9/chapter9.sql。

深度学习简介

深度学习是一种使用算法分析和学习数据以产生类似人类输出的人工智能（AI）。深度学习可以利用人工神经网络（ANNs）进行监督学习和无监督学习。在深度学习中，通过一个称为 MLP 的前馈 ANN（多层感知器）从输入层生成一系列输出。MLP 利用反向传播将输出中的错误反馈到层中，一次计算一层，直到模型学会了输入数据中的模式和关系，从而得到特定的输出。

特征学习是一组技术，其中机器使用原始数据推导出数据中类的特征，以推导出特定任务。深度学习模型有效地使用特征学习来学习复杂、冗余和可变输入数据，并对指定任务进行分类。因此，它消除了手动特征工程来设计和选择输入特征的需求。当你的数据集不能通过一条直线（称为非线性数据）分离时，深度学习非常有用。

例如，在将金融交易分类为欺诈或合法时，两个数据类别之间可能没有明确的线性边界。在这种情况下，深度学习模型可以学习输入数据特征之间的这些可变和复杂的非线性关系，从而提高目标分类的准确性。

当处理分类问题时，确定您的数据集是否线性分离的一个简单方法是为类别绘制散点图，看看两个类别是否可以通过一条线来分离。在下面的图中，左侧图表显示两个类别是线性分离的，而右侧图表显示它们不是：

图 9.1 – 线性与非线性数据集

当您的数据集无法通过 MLP 算法线性分离时，您可以在 Redshift ML 中创建模型。MLP 算法有用的常见用例如下：

• 语音识别

• 图像识别

• 机器翻译

本章将向您展示如何使用 MLP 算法在 Amazon Redshift ML 中构建深度学习模型。

商业问题

我们将使用一个跟随墙壁的机器人导航数据集，使用 MLP 算法构建机器学习模型。机器人配备了超声波传感器，当机器人在顺时针方向穿过房间时，数据被收集。这里的目的是通过给出简单的指令，如前进、轻微右转、急右转和轻微左转，来引导机器人沿着墙壁行走。

由于对于一组给定的传感器读数存在要预测的类别，这将是一个多类问题。我们将使用 MLP 来正确引导机器人沿着墙壁行走。（此数据来自archive.ics.uci.edu/ml/datasets/Wall-Following+Robot+Navigation+Data，归功于 Ananda Freire、Marcus Veloso 和 Guilherme Barreto（2019）。UCI 机器学习库[archive.ics.uci.edu/ml]。加州大学欧文分校：加州大学信息与计算机科学学院。）

请遵循页面上的详细文档以了解更多关于用例的使用。

现在，您将上传数据，分析它，并为训练模型做准备。

上传和分析数据

我们在以下 S3 位置存储了传感器读数数据：

s3://packt-serverless-ml-redshift/chapter09/

成功连接到 Redshift 作为管理员或数据库开发者后，将数据加载到 Amazon Redshift 中：

1. 导航到Redshift 查询编辑器 v2，连接到Serverless: workgroup2，然后连接到dev数据库：

图 9.2 – 连接到开发数据库

1. 执行以下步骤以创建模式和客户表，并加载数据：

   create schema chapter9_deeplearning;
   

   create table chapter9_deeplearning.robot_navigation (
   

        id bigint identity(0,1),
   

   us1 float, us2 float, us3 float, us4 float, us5 float, us6 float, us7 float, us8 float, us9 float,us10 float, us11 float, us12 float, us13 float, us14 float, us15 float, us16 float, us17 float, us18 float, us19 float, us20 float, us21 float, us22 float, us23 float, us24 float, direction varchar(256)
   

   )
   

   diststyle auto;
   

   copy chapter9_deeplearning.robot_navigation from 's3://packt-serverless-ml-redshift/chapter09/sensor_readings_24.data'
   

   iam_role  default
   

   format as csv
   

   delimiter ','
   

   quote '"'
   

   region as 'eu-west-1'
   

   ;
   

2. 运行以下查询以检查一些样本数据：

   select * from
   

   chapter9_deeplearning.robot_navigation
   

   limit 10;
   

在图 9.3 中，我们可以看到我们的数据已成功加载：

图 9.3 – 样本输出

从前面的屏幕截图，我们可以看到有几个传感器读数。运行以下查询以查看机器人运动的不同方向的分布，如图图 9.4 所示：

select direction, count(*)
from chapter9_deeplearning.robot_navigation
group by 1;

要将结果以柱状图的形式查看，请点击结果面板上的图表切换按钮 ()。在跟踪下，点击+ 跟踪 ()，并将类型设置为柱状图，X 轴设置为方向，Y 轴从下拉菜单中选择计数。保持方向为垂直。

图 9.4 – 使用查询编辑器 v2 生成的图形

你可以注意到，急转右转和前进方向的数量比轻微右转和轻微左转方向的数量多。我们将使用这些输入来预测机器人的未来运动。

预测目标

由于这是一个多类分类问题，这个模型的目标是根据 24 个传感器读数预测机器人将采取的方向。

数据集有一个 ID 列，它唯一地标识了 24 个传感器读数，命名为us1、us2、…、us24，以及一个direction变量，其中包含 4 个值。direction变量是我们试图预测的类别变量。

现在我们将数据集分成训练数据集，它将被输入到我们的模型中，以及测试数据集，我们将用它来做预测。

将数据分割成训练集和测试集

我们将把我们的表分成两个数据集，训练集和测试集，大约 80:20 的比例。让我们在 Redshift 中使用mod函数来分割我们的表。mod函数返回两个数字的余数。我们将传入 ID 和数字5。

为了训练模型，让我们使用where mod(id,5)不等于0，这代表我们的 80%的训练集。在 Query Editor v2 中运行以下命令：

select direction, count(*)
from chapter9_deeplearning.robot_navigation
where mod(id,5) <> 0
group by 1;

在图 9.5 中，我们看到基于大约 80%的数据的数据分布：

图 9.5 – 训练数据集分布

注意

你可能看到的计数与我们展示的不同。我们正在使用 Redshift 的Identity函数来生成id列的值。为了确保身份值是唯一的，Amazon Redshift 在创建身份值时会跳过一些值。身份值是唯一的，但顺序可能不匹配。因此，你可能看到不同的计数，但数据是总计数的 80%（5,456 行）。

Query Editor v2 中的图表函数以柱状图格式显示了这一点，如图图 9.6 所示：

图 9.6 – 训练集柱状图

为了测试模型，让我们使用where mod(id,5)等于0，这代表我们的 20%测试数据集：

select direction, count(*) from chapter9_deeplearning.robot_navigation
where mod(id,5) = 0
group by 1;

在图 9.7 中，我们看到基于~20%的数据的数据分布：

图 9.7 – 测试数据集分布

Query Editor v2 中的Chart函数以条形图格式显示了图 9.8 中的内容：

图 9.8 – 测试数据条形图

现在我们已经分析了我们的数据，并确定了如何将其分割成训练集和测试集，让我们使用 MLP 算法创建我们的模型。

使用 MLP 创建多类分类模型

在这个练习中，我们将指导CREATE MODEL语句使用 MLP 模型。您将通过将model_type参数设置为MLP来实现这一点。其余参数可以设置为默认值。

让我们创建一个预测机器人方向的模型：

CREATE MODEL chapter9_deeplearning.predict_robot_direction
from  (select
us1 ,us2 , us3 , us4 , us5 , us6 ,us7 , us8 , us9 ,
us10 ,us11 ,us12 ,us13 ,us14 ,us15 ,us16 ,us17 ,
us18 ,us19 ,us20 ,us21 , us22 ,us23 ,us24 , direction
  from chapter9_deeplearning.robot_navigation
  where mod(id,5) !=0)
target direction
function predict_robot_direction_fn
iam_role default
model_type mlp
settings (s3_bucket 'replace-with-your-s3-bucket',
max_runtime 1800);

使用CREATE MODEL函数时，设置了max_runtime值为1800秒。这意味着模型训练的最大时间是 30 分钟。训练作业通常根据数据集的大小完成得更快。由于我们没有设置其他参数（例如，目标或问题类型），Amazon SageMaker Autopilot 将为我们识别参数的大部分工作。

运行SHOW MODEL命令以检查模型训练是否完成：

SHOW MODEL chapter9_deeplearning.predict_robot_direction;

在图 9.9 中检查模型状态：

图 9.9 – SHOW MODEL 输出

从前面的屏幕截图可以看出，模型状态字段显示状态为训练中，这意味着模型仍在训练中。但请注意，Redshift ML 已将模型类型识别为mlp；其他参数，如问题类型和目标现在为空，但在模型训练完成后，我们将看到这些值。

在一段时间后再次运行SHOW MODEL命令以检查模型训练是否完成。从下面的屏幕截图可以看出，模型训练已完成，准确率已被选为模型评估的目标。这是由 Redshift ML 自动选择的。同时请注意，Redshift ML 正确地将此识别为多类分类问题：

图 9.10 – SHOW MODEL 输出

现在我们已经完成了模型的训练，让我们使用创建的函数进行预测。在图 9.10 中，predict_robot_direction_fn，我们将在预测查询中引用它。

还请注意图 9.10 中的validation:accuracy值为.940026。这意味着我们的模型准确率超过 94%，这非常好。

注意

由于在后台算法中选择了不同的超参数，您可能会得到不同的准确率值，这可能会略微影响准确率。

由于我们的模型已经成功训练，让我们在我们的测试数据集上运行一些预测。

运行预测

在这个第一个查询中，我们将使用CREATE MODEL命令返回的函数来比较实际方向与我们的预测方向。在 Query Editor v2 中运行以下查询以查看我们预测正确的次数：

select correct, count(*)
from
(select  DIRECTION as actual, chapter9_deeplearning.predict_robot_direction_fn (
US1,US2,US3,US4,US5,US6,US7,US8,US9,US10,US11,US12,
US13,US14,US15,US16,US17,US18,US19,US20,US21,US22,US23,US24
 ) as  predicted,
  CASE WHEN actual = predicted THEN 1::INT
         ELSE 0::INT END AS correct
from chapter9_deeplearning.robot_navigation
where MOD(id,5) =0
) t1
group by 1;

在*图 9**.11 中，我们看到我们的模型正确预测了机器人方向 1,033 次。

请注意，您的计数可能会有所不同：

图 9.11 – 实际方向与预测方向

现在，让我们对测试数据集运行一个查询以预测机器人将移动的方向。在 Query Editor v2 中运行以下查询以返回前 10 行：

 select  id, chapter9_deeplearning.predict_robot_direction_fn (
US1,US2,US3,US4,US5,US6,US7,US8,US9,US10,US11,US12,
US13,US14,US15,US16,US17,US18,US19,US20,US21,US22,US23,US24
 ) as  predicted_direction
from chapter9_deeplearning.robot_navigation
where MOD(id,5) <> 0
limit 10;

在图 9**.12中，我们展示了基于 ID 的前 10 行和方向：

图 9.12 – 根据 ID 预测的方向

现在，让我们修改查询以总结我们预测的机器人运动。在 Query Editor v2 中运行以下命令：

select chapter9_deeplearning.predict_robot_direction_fn (
US1,US2,US3,US4,US5,US6,US7,US8,US9,US10,US11,US12,
US13,US14,US15,US16,US17,US18,US19,US20,US21,US22,US23,US24
 ) as  predicted_direction, count(*)
from chapter9_deeplearning.robot_navigation
where MOD(id,5) <> 0
group by 1;

在*图 9.13 中，我们可以看到前进是最受欢迎的方向，其次是急右转**。请注意，您的计数可能会有所不同。

图 9.13 – 预测方向的总结

您现在已使用 MLP 算法创建了一个模型，并在测试数据集上运行了预测。

总结

在本章中，我们讨论了深度学习模型及其必要性，并展示了如何使用 MLP 算法在传感器读数数据上创建一个 MLP 模型来预测机器人的下一步动作。您了解到非线性数据集适合深度学习，并使用 MLP 算法创建了一个多类分类模型。

在下一章中，我们将向您展示如何使用 XGBoost 算法创建一个完全控制超调参数的模型。

第十章：使用 XGBoost 创建自定义 ML 模型

到目前为止，我们探索的所有监督学习模型都使用了Amazon Redshift Auto ML功能，该功能在幕后使用Amazon SageMaker Autopilot。在本章中，我们将探讨如何创建自定义机器学习（ML）模型。训练自定义模型让你有选择模型类型和使用超参数的灵活性。本章将提供这种建模技术的示例。到本章结束时，你将知道如何创建自定义 XGBoost 模型以及如何使用 Redshift SQL 准备训练模型的数据。

在本章中，我们将讨论以下主要主题：

• 介绍 XGBoost

• 介绍 XGBoost 用例

• 带有自动关闭功能的 XGBoost 模型

技术要求

本章需要网络浏览器以及访问以下内容：

• 一个 AWS 账户

• Amazon Redshift 无服务器端点

• Amazon Redshift 查询编辑器 v2

你可以在此处找到本章使用的代码：

github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter10/chapter10.sql

介绍 XGBoost

XGBoost之所以得名，是因为它是建立在梯度提升框架之上的。使用树提升技术为解决 ML 问题提供了一种快速方法。正如你在前面的章节中看到的，你可以指定模型类型，这有助于加快模型训练，因为SageMaker Autopilot不需要确定使用哪种模型类型。

你可以在此处了解更多关于 XGBoost 的信息：docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html。

当你使用 Redshift ML 创建一个模型，并指定 XGBoost 作为模型类型，并且可选地指定 AUTO OFF 时，这将关闭 SageMaker Autopilot，并让你对模型调优有更多的控制。例如，你可以指定你希望使用的超参数。你将在使用 XGBoost 创建二元分类模型部分看到这个示例。

当你将AUTO设置为OFF时，你将需要进行预处理。执行预处理确保我们将获得最佳模型，并且由于当你将AUTO设置为OFF时，所有输入都必须是数值型的，这也是必要的，例如，确保数据被清理，分类变量被编码，数值变量被标准化。你还需要确定你遇到的问题类型，并选择一个合适的模型进行训练。你将能够创建训练和测试数据集，并自行评估模型。你还有能力调整超参数。总之，你将获得对端到端 ML 模型训练和构建的完全控制。

通过使用 Amazon Redshift ML 的 XGBoost，你可以解决回归和分类问题。你还可以指定你模型的训练目标。例如，如果你正在解决一个二元分类问题，你会选择binary:logistic作为你的目标，或者对于多类分类问题使用multi:softmax。

在撰写本书时，支持的训练目标包括reg:squarederror、reg:squaredlogerror、reg:logistic、reg:pseudohubererror、reg:tweedie、binary:logistic、binary:hinge和multi:softmax。

有关这些目标的更多信息，请参阅 XGBoost 文档中的学习任务参数部分：xgboost.readthedocs.io/en/latest/parameter.html#learning-task-parameters。

现在你已经了解了 XGBoost 是什么，我们将看看一个用例，其中我们可以应用 XGBoost 并使用二元分类解决一个常见的业务问题。

介绍 XGBoost 用例

在本节中，我们将讨论一个用例，其中我们想要预测信用卡交易是否为欺诈。我们将进行以下步骤：

• 定义业务问题

• 上传、分析和准备训练数据

• 将数据分为训练集和测试集

• 预处理输入变量

定义业务问题

在本节中，我们将使用信用卡支付交易数据集，在 Redshift ML 中使用 XGBoost 构建一个二元分类模型。此数据集包含客户和终端信息，以及与交易相关的日期和金额。此数据集还有一些基于最近性、频率和货币数值特征的派生字段，以及一些分类变量，例如交易是否发生在周末或夜间。我们的目标是识别交易是否为欺诈或非欺诈。此用例来自github.com/Fraud-Detection-Handbook/fraud-detection-handbook。请参阅 GitHub 存储库以了解更多关于此数据生成过程的信息。

数据集引用

可重复的机器学习用于信用卡欺诈检测 - 实用手册，Le Borgne, Yann-Aël 和 Siblini, Wissam 以及 Lebichot, Bertrand 和 Bontempi, Gianluca，github.com/Fraud-Detection-Handbook/fraud-detection-handbook，2022，布鲁塞尔自由大学

现在，我们将我们的数据集加载到 Amazon Redshift ML 中，并为其模型训练做准备。

上传、分析和准备训练数据

在我们开始之前，让我们首先以管理员或数据库开发者的身份连接到 Redshift，然后将数据加载到 Amazon Redshift 中。

在以下步骤中，您将创建所有需要的表和对象的模式，这包括创建所有需要的表、加载数据以及创建用于数据转换的视图。

导航到查询编辑器 v2，连接到无服务器端点，然后连接到 dev 数据库，如下截图所示：

图 10.1 – 连接到查询编辑器 v2

1. 执行以下步骤以创建模式。此模式将用于本章中创建的所有对象和模型：

   CREATE SCHEMA  chapter10_xgboost;
   

2. 接下来，将以下 SQL 语句复制到查询编辑器 v2 中以创建用于托管客户支付交易历史的表，我们将在后续步骤中加载数据：

   create table chapter10_xgboost.cust_payment_tx_history
   

   (
   

   transaction_id integer,
   

   tx_datetime timestamp,
   

   customer_id integer,
   

   terminal_id integer,
   

   tx_amount decimal(9,2),
   

   tx_time_seconds integer,
   

   tx_time_days integer,
   

   tx_fraud integer,
   

   tx_fraud_scenario integer,
   

   tx_during_weekend integer,
   

   tx_during_night integer,
   

   customer_id_nb_tx_1day_window decimal(9,2),
   

   customer_id_avg_amount_1day_window decimal(9,2),
   

   customer_id_nb_tx_7day_window decimal(9,2),
   

   customer_id_avg_amount_7day_window decimal(9,2),
   

   customer_id_nb_tx_30day_window decimal(9,2),
   

   customer_id_avg_amount_30day_window decimal(9,2),
   

   terminal_id_nb_tx_1day_window decimal(9,2),
   

   terminal_id_risk_1day_window decimal(9,2),
   

   terminal_id_nb_tx_7day_window decimal(9,2),
   

   terminal_id_risk_7day_window decimal(9,2),
   

   terminal_id_nb_tx_30day_window decimal(9,2),
   

   terminal_id_risk_30day_window decimal(9,2)
   

   )
   

   ;
   

3. 现在您已经创建了表，您可以在查询编辑器 v2 中执行以下命令来加载数据表：

   copy chapter10_xgboost.cust_payment_tx_history
   

   from 's3://packt-serverless-ml-redshift/chapter10/credit_card_transactions_transformed_balanced.csv'
   

   iam_role default
   

   ignoreheader 1
   

   csv region 'eu-west-1';
   

4. 现在您已经加载数据，一个好的做法是采样一些数据以确保我们的数据加载正确。运行以下查询以采样 10 条记录：

   select * from
   

   chapter10_xgboost.cust_payment_tx_history
   

   limit 10;
   

在以下截图中，我们可以看到我们已经正确加载了数据，并采样了不同的交易 ID：

图 10.2 – 数据样本

如前几章所述，目标变量是我们试图在模型中预测的值。在我们的用例中，我们试图预测交易是否为欺诈。在我们的数据集中，这是 tx_fraud 属性，即我们的目标。让我们检查我们的表以查看有多少笔交易被标记为欺诈。

在查询编辑器 v2 中运行以下命令：

select tx_fraud, count(*)
from chapter10_xgboost.cust_payment_tx_history
group by 1;

我们将数据集中的欺诈交易识别为 tx_fraud 值为 1 的交易。我们在数据集中已识别出 14,681 笔欺诈交易。相反，tx_fraud 值为 0 表示交易不是欺诈：

图 10.3 – 欺诈交易

让我们查看欺诈和非欺诈交易在几个月内的趋势。我们想要分析是否存在任何欺诈交易的不寻常峰值。

在查询编辑器 v2 中运行以下 SQL 命令：

select to_char(tx_datetime, 'yyyymm') as yearmonth,
sum(case when tx_fraud = 1 then 1 else 0 end) fraud_tx,
sum(case when tx_fraud = 0 then 1 else 0 end) non_fraud_tx,
count(*) as total_tx,
(fraud_tx::decimal(10,2 ) / total_tx::decimal(10,2) ) *100 as fraud_txn_pct
from chapter10_xgboost.cust_payment_tx_history
group by yearmonth
order by yearmonth

注意到欺诈交易在 202207 相比 202206 增加了近 8%：

图 10.4 – 欺诈交易趋势

现在我们已经加载数据，让我们通过将数据分割成训练集和测试集来准备我们的数据以供模型训练。训练数据用于训练模型，测试数据用于运行我们的预测查询。

将数据分割成训练集和测试集

为了训练模型，我们将使用 2022-10-01 之前的交易，这大约占交易总数的 80%。

为了测试模型，我们将使用 2022-09-30 之后的交易数据，这占交易总数的 20%。

预处理输入变量

在我们的输入字段中，我们有数值和分类变量的组合。我们需要将分类变量预处理为独热编码值并标准化数值变量。由于我们将使用 自动关闭，SageMaker 不会自动预处理数据。因此，转换各种数值、日期和时间特征非常重要。

分类特征（也称为名义变量）具有不同的类别或级别。这些可以是没有任何顺序的类别，例如国家或性别。或者它们可以有顺序，例如教育水平（也称为有序变量）。

由于机器学习模型需要在 数值变量 上操作，我们需要应用有序编码或独热编码。

为了使事情更简单，我们创建了一个视图来处理转换逻辑。这个视图有点长，但实际上，视图所做的是相当简单的：

• 计算交易时间（以秒和天为单位）

• 通过分配 0 或 1 来进行独热编码，以将交易分类为工作日、周末、白天或夜间（例如 TX_DURING_WEEKEND 或 TX_DURING_NIGHT）

• 对交易应用窗口函数，以便我们可以在 1 天、7 天和 30 天的时间间隔内轻松可视化数据

在 Query Editor v2 中执行以下 SQL 命令以通过应用转换逻辑创建视图：

create view chapter10_xgboost.credit_payment_tx_history_scaled
as
select
transaction_id, tx_datetime, customer_id, terminal_id,
tx_amount ,
( (tx_amount - avg(tx_amount) over()) /  cast(stddev_pop(tx_amount) over() as dec(14,2)) ) s_tx_amount,
tx_time_seconds ,
  ( (tx_time_seconds - avg(tx_time_seconds) over()) /  cast(stddev_pop(tx_time_seconds) over() as dec(14,2)) ) s_tx_time_seconds,
tx_time_days  ,
  ( (tx_time_days - avg(tx_time_days) over()) /  cast(stddev_pop(tx_time_days) over() as dec(14,2)) ) s_tx_time_days,
tx_fraud  ,
  tx_during_weekend ,
case when tx_during_weekend = 1 then 1 else 0 end as tx_during_weekend_ind,
case when tx_during_weekend = 0 then 1 else 0 end tx_during_weekday_ind,
tx_during_night,
case when tx_during_night = 1 then 1 else 0 end as tx_during_night_ind,
case when tx_during_night = 0 then 1 else 0 end as tx_during_day_ind,
customer_id_nb_tx_1day_window ,
  ( (customer_id_nb_tx_1day_window - avg(customer_id_nb_tx_1day_window) over()) /  cast(stddev_pop(customer_id_nb_tx_1day_window) over() as dec(14,2)) ) s_customer_id_nb_tx_1day_window,
customer_id_avg_amount_1day_window  ,
  ( (customer_id_avg_amount_1day_window - avg(customer_id_avg_amount_1day_window) over()) /  cast(stddev_pop(customer_id_avg_amount_1day_window) over() as dec(14,2)) ) s_customer_id_avg_amount_1day_window,
customer_id_nb_tx_7day_window ,
  ( (customer_id_nb_tx_7day_window - avg(customer_id_nb_tx_7day_window) over()) /  cast(stddev_pop(customer_id_nb_tx_7day_window) over() as dec(14,2)) ) s_customer_id_nb_tx_7day_window,
customer_id_avg_amount_7day_window  ,
  ( (customer_id_avg_amount_7day_window - avg(customer_id_avg_amount_7day_window) over()) /  cast(stddev_pop(customer_id_avg_amount_7day_window) over() as dec(14,2)) ) s_customer_id_avg_amount_7day_window,
customer_id_nb_tx_30day_window  ,
  ( (customer_id_nb_tx_30day_window - avg(customer_id_nb_tx_30day_window) over()) /  cast(stddev_pop(customer_id_nb_tx_30day_window) over() as dec(14,2)) ) s_customer_id_nb_tx_30day_window,
customer_id_avg_amount_30day_window ,
  ( (customer_id_avg_amount_30day_window - avg(customer_id_avg_amount_30day_window) over()) /  cast(stddev_pop(customer_id_avg_amount_30day_window) over() as dec(14,2)) ) s_customer_id_avg_amount_30day_window,
terminal_id_nb_tx_1day_window ,
  ( (terminal_id_nb_tx_1day_window - avg(terminal_id_nb_tx_1day_window) over()) /  cast(stddev_pop(terminal_id_nb_tx_1day_window) over() as dec(14,2)) ) s_terminal_id_nb_tx_1day_window,
terminal_id_risk_1day_window  ,
  ( (terminal_id_risk_1day_window - avg(terminal_id_risk_1day_window) over()) /  cast(stddev_pop(terminal_id_risk_1day_window) over() as dec(14,2)) ) s_terminal_id_risk_1day_window,
terminal_id_nb_tx_7day_window ,
  ( (terminal_id_nb_tx_7day_window - avg(terminal_id_nb_tx_7day_window) over()) /  cast(stddev_pop(terminal_id_nb_tx_7day_window) over() as dec(14,2)) ) s_terminal_id_nb_tx_7day_window,
terminal_id_risk_7day_window  ,
  ( (terminal_id_risk_7day_window - avg(terminal_id_risk_7day_window) over()) /  cast(stddev_pop(terminal_id_risk_7day_window) over() as dec(14,2)) ) s_terminal_id_risk_7day_window,
terminal_id_nb_tx_30day_window  ,
  ( (terminal_id_nb_tx_30day_window - avg(terminal_id_nb_tx_30day_window) over()) /  cast(stddev_pop(terminal_id_nb_tx_30day_window) over() as dec(14,2)) ) s_terminal_id_nb_tx_30day_window,
terminal_id_risk_30day_window ,
  ( (terminal_id_risk_30day_window - avg(terminal_id_risk_30day_window) over()) /  cast(stddev_pop(terminal_id_risk_30day_window) over() as dec(14,2)) ) s_terminal_id_risk_30day_window
from
chapter10_xgboost.cust_payment_tx_history;

现在视图已创建，让我们采样 10 条记录。

在 Query Editor v2 中执行以下命令：

SELECT * from chapter10_XGBoost.credit_payment_tx_history_scaled limit 10;

我们可以在以下屏幕截图中看到一些我们的转换值，例如 tx_time_seconds 和 txn_time_days：

图 10.5 – 转换后的数据

现在，让我们快速回顾一下为什么我们需要创建这个视图：

• 由于我们使用 XGBoost 与自动关闭，我们必须自己进行数据预处理和特征工程

• 我们对分类变量应用了独热编码

• 我们对数值变量进行了缩放

这里是视图逻辑的摘要：

• 我们使用的目标变量是 TX_FRAUD

• 我们使用的分类变量是 TX_DURING_WEEKEND_IND, TX_DURING_WEEKDAY_IND, TX_DURING_NIGHT_IND, 和 TX_DURING_DAY_IND

• 缩放后的数值变量是 s_customer_id_nb_tx_1day_window, s_customer_id_avg_amount_1day_window, s_customer_id_nb_tx_7day_window, s_customer_id_avg_amount_7day_window, s_customer_id_nb_tx_30day_window, s_customer_id_avg_amount_30day_window, s_terminal_id_nb_tx_1day_window, s_terminal_id_risk_1day_window, s_terminal_id_nb_tx_7day_window, s_terminal_id_risk_7day_window, s_terminal_id_nb_tx_30day_window, 和 s_terminal_id_risk_30day_window

你现在已经完成了数据准备，并准备好创建你的模型！

使用 XGBoost 自动关闭创建模型

在这个练习中，我们将使用 XGBoost 算法创建一个自定义的二进制分类模型。你可以通过设置 自动关闭 来实现这一点。以下是可用的参数：

• 自动关闭

• 模型类型

• 目标

• 超参数

关于可用的超参数值及其默认值的完整列表，请阅读以下文档：

docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_auto_off_create_model

现在你已经了解了 XGBoost 提供的参数，你可以创建模型。

使用 XGBoost 创建二元分类模型

让我们创建一个模型来预测交易是欺诈还是非欺诈。正如你在前面的章节中学到的，使用 Amazon Redshift ML 创建模型只需运行一个创建函数的 SQL 命令。作为输入（或特征），你将使用你在上一节中创建的视图中的属性。你将指定tx_fraud作为目标，并给出函数名称，你将在后续的预测查询中使用它。此外，你将指定超参数以进行自己的模型调优。让我们开始吧！

在查询编辑器 v2 中执行以下命令。以下是一个代码片段；你可以从以下 URL 获取完整的代码：

github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/chapter10.sql

drop model chapter10_XGBoost.cust_cc_txn_fd_xg;
 create model chapter10_xgboost.cust_cc_txn_fd_xg
from (
select
  s_tx_amount,
tx_fraud,
…
  from chapter10_xgboost.payment_tx_history_scaled
  where cast(tx_datetime as date) between '2022-06-01' and '2022-09-30'
)
target tx_fraud
function fn_customer_cc_fd_xg
iam_role default
auto off
model_type xgboost
objective 'binary:logistic'
preprocessors 'none'
hyperparameters default except (num_round '100')
settings (
  s3_bucket '<<your-s3-bucket>>',
            s3_garbage_collect off,
            max_runtime 1500
                   );

CREATE MODEL函数将调用 XGBoost 算法并训练一个二元分类模型。我们将num_round超参数值设置为100，这是训练运行的轮数。

现在，让我们运行 SHOW MODEL 来查看模型训练是否完成。在查询编辑器 v2 中运行以下命令：

SHOW MODEL  chapter10_XGBoost.cust_cc_txn_fd_xg;

注意以下截图中的模型状态，它显示你的模型仍在训练中：

图 10.6 – 显示模型输出

从前面的截图，我们注意到CREATE MODEL语句的值模型类型设置为xgboost。objective设置为binary:logistic，而num_round参数设置为100。

当你有一个自动关闭的自定义模型并指定超参数时，模型可以训练得更快。这个模型通常在 10 分钟内完成。

10 分钟后再次运行SHOW MODEL命令来检查模型训练是否完成。如以下截图所示，模型训练已完成，train:error字段报告了错误率。大多数数据集的阈值是.5，所以我们的0.051870值非常好，如以下截图所示：

图 10.7 – SHOW MODEL 输出

现在，你的模型已经完成，并且基于score – train_error的得分很好，为0.051870。你现在可以使用它进行预测。

生成预测和评估模型性能

在查询编辑器 v2 中运行以下查询，该查询将比较实际的 tx_fraud 值与 predicted_tx_fraud 值：

select
tx_fraud ,
fn_customer_cc_fd_xg(
s_tx_amount,
tx_during_weekend_ind,
tx_during_weekday_ind,
tx_during_night_ind,
tx_during_day_ind,
s_customer_id_nb_tx_1day_window,
s_customer_id_avg_amount_1day_window,
s_customer_id_nb_tx_7day_window,
s_customer_id_avg_amount_7day_window,
s_customer_id_nb_tx_30day_window,
s_customer_id_avg_amount_30day_window,
s_terminal_id_nb_tx_1day_window,
s_terminal_id_risk_1day_window,
s_terminal_id_nb_tx_7day_window,
s_terminal_id_risk_7day_window,
s_terminal_id_nb_tx_30day_window,
s_terminal_id_risk_30day_window)
from chapter10_xgboost.credit_payment_tx_history_scaled
where cast(tx_datetime as date) >= '2022-10-01'
;

以下截图显示了样本输出。在此截图中，我们的预测值与实际值相同：

图 10.8 – 推理查询输出

由于我们没有从 Redshift ML 获取我们模型的 F1 值，让我们来计算它。我们将创建一个包含完成此逻辑的视图：

--drop view if exists chapter10_xgboost.fraud_tx_conf_matrix;
create or replace view chapter10_xgboost.fraud_tx_conf_matrix
as
select
transaction_id,tx_datetime,customer_id,tx_amount,terminal_id, tx_fraud,
  fn_customer_cc_fd_xg(
  s_tx_amount,
tx_during_weekend_ind,
tx_during_weekday_ind,
tx_during_night_ind,
tx_during_day_ind,
s_customer_id_nb_tx_1day_window,
s_customer_id_avg_amount_1day_window,
s_customer_id_nb_tx_7day_window,
s_customer_id_avg_amount_7day_window,
s_customer_id_nb_tx_30day_window,
s_customer_id_avg_amount_30day_window,
s_terminal_id_nb_tx_1day_window,
s_terminal_id_risk_1day_window,
s_terminal_id_nb_tx_7day_window,
s_terminal_id_risk_7day_window,
s_terminal_id_nb_tx_30day_window,
s_terminal_id_risk_30day_window)
as prediction,
case when tx_fraud  =1 and prediction = 1 then 1 else 0 end truepositives,
case when tx_fraud =0 and prediction = 0 then 1 else 0 end truenegatives,
case when tx_fraud =0 and prediction = 1 then 1 else 0 end falsepositives,
case when tx_fraud =1 and prediction = 0 then 1 else 0 end falsenegatives
  from chapter10_xgboost.credit_payment_tx_history_scaled
  where cast(tx_datetime as date) >= '2022-10-01';

在查询编辑器 v2 中运行以下 SQL 命令以检查我们在视图中计算的 F1 分数：

select
sum(truepositives+truenegatives)*1.00/(count(*)*1.00) as accuracy,--accuracy of the model,
sum(falsepositives+falsenegatives)*1.00/count(*)*1.00 as error_rate, --how often model is wrong,
sum(truepositives)*1.00/sum (truepositives+falsenegatives) *1.00 as tpr, --or recall how often corrects are rights,
sum(falsepositives)*1.00/sum (falsepositives+truenegatives )*1.00 fpr, --or fall-out how often model said yes when it is no,
sum(truenegatives)*1.00/sum (falsepositives+truenegatives)*1.00 tnr, --or specificity, how often model said no when it is yes,
sum(truepositives)*1.00 / (sum (truepositives+falsepositives)*1.00) as precision, -- when said yes how it is correct,
2*((tpr*precision)/ (tpr+precision) ) as f_score --weighted avg of tpr & fpr
from chapter10_xgboost.fraud_tx_conf_matrix
;

你可以看到我们的准确率是 90%，F1 分数是 87%，这两个指标都非常出色。此外，我们的混淆矩阵值告诉我们我们正确预测 True 和正确预测 False 的次数：

图 10.9 – F1 分数

现在，让我们检查实际与预测计数。在查询编辑器 v2 中运行以下查询：

select tx_fraud,prediction, count(*)
from chapter10_xgboost.fraud_tx_conf_matrix
group by tx_fraud,prediction;

以下截图的输出显示了对于给定值，我们的预测值与实际值以及这些记录的数量相比。我们的模型错误地预测了 178 次欺诈交易，错误地预测了 1,081 次非欺诈交易：

图 10.10 – 混淆矩阵

这展示了 Redshift ML 如何帮助你自信地预测一笔交易是否为欺诈。

摘要

在本章中，你学习了 XGBoost 是什么以及如何将其应用于商业问题。你学习了在使用 Auto Off 选项时如何指定自己的超参数，以及如何为二分类问题指定目标。此外，你还学习了如何进行自己的数据预处理并计算 F1 分数以验证模型性能。

在下一章中，你将学习如何将你的模型从 Amazon SageMaker 带入数据库或远程推理。

第十一章：数据库推理的自定义模型

在本书中，我们介绍了使用Redshift 机器学习（Redshift ML）原生训练模型的过程。然而，可能存在需要利用 Redshift 外部构建的模型的情况。为了解决这个问题，Redshift ML 提供了Bring Your Own Model（BYOM）功能，允许用户将他们的 Amazon SageMaker 机器学习模型与 Amazon Redshift 集成。此功能便于在仓库中存储的数据上执行预测和其他机器学习任务，而无需数据移动。

BYOM 提供了两种方法：本地推理和远程推理。在本章中，我们将深入探讨 BYOM 的工作原理，并探索创建和集成 BYOM 的各种选项。您将指导完成在 Amazon SageMaker 中构建机器学习模型的过程，随后使用 Redshift ML 的 BYOM 功能将模型引入 Redshift。此外，您还将学习如何将这些模型应用于存储在 Redshift 数据仓库中的数据以进行预测。

到本章结束时，您将熟练地将 Amazon SageMaker 创建的模型在 Amazon Redshift 中执行预测。利用 BYOM，您可以将XGBoost和多层感知器（MLP）等模型部署到 Redshift ML。一旦在 Redshift ML 上部署了预训练模型，您就可以在 Redshift 上本地运行推理，而不依赖于 SageMaker 端点或 SageMaker Studio。这种简单性使数据分析师能够使用外部创建的模型对新的数据进行推理，消除了访问 SageMaker 服务的担忧。

此方法显著加快了将 Redshift 外部创建的机器学习模型交付给数据团队的速度。此外，由于 Redshift ML 与原生 Redshift SQL 交互，数据团队的用户体验与其他在数据仓库上执行的数据分析工作保持一致。

在本章中，我们将讨论以下主要主题：

• BYOM 的好处

• 支持的模型类型

• BYOM 用于本地推理

• BYOM 用于远程推理

技术要求

本章需要网络浏览器和以下访问权限：

• 一个 AWS 账户

• 一个 Amazon Redshift Serverless 端点

• 一个 Amazon SageMaker 笔记本

• Amazon Redshift 查询编辑器 v2

• 完成第一章中的“Amazon Redshift Serverless 入门”部分

您可以在此处找到本章节使用的代码：

github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift

本章节所需的数据文件位于一个公共的 S3 桶中：s3://packt-serverless-ml-redshift/。

让我们开始吧！

BYOM 的好处

使用 Amazon Redshift ML，您可以使用在 Amazon SageMaker 中构建的现有机器学习模型，并在 Redshift 中使用它，而无需重新训练。要使用 BYOM，您需要提供模型工件或 SageMaker 端点，该端点接收一批数据并返回预测。BYOM 在机器学习模型尚未在 Redshift ML 中可用的情况下很有用，例如，在撰写本书时，随机切割森林模型尚未在 Redshift ML 中可用，因此您可以在 SageMaker 中构建此模型，并轻松将其带到 Redshift，然后使用它来处理存储在 Redshift 中的数据。

使用 Redshift ML 与您自己的机器学习模型有一些具体的优势：

• 提高效率：通过使用现有的机器学习模型，您可以节省在训练新模型上花费的时间和资源。

• 易于集成：Redshift ML 使将您的机器学习模型集成到您的数据管道变得容易，允许您用于实时预测或批量预测。

• 可扩展性：Redshift ML 是建立在高度可扩展且性能卓越的 Amazon Redshift 数据仓库之上的，因此你可以使用你的机器学习模型对大型数据集进行预测，而无需担心性能问题。

支持的模型类型

Amazon Redshift ML 通过 BYOM 功能支持广泛的机器学习模型。可以使用 BYOM 的常见模型类型包括以下几种：

• 线性回归模型：这些模型类似于数字预测器。它们考虑几个因素或特征，并使用它们来猜测特定的数值结果。例如，如果你想预测一栋房子的价格，线性回归模型会考虑诸如房子的面积、房间数量和位置等因素，以估计房子的价格。

• 逻辑回归模型：这些模型是二元结果预测器。它们不是猜测数字，而是回答“是”或“否”的问题，或者做出0/1的预测。例如，如果你想预测一个学生是否会通过或失败考试，逻辑回归模型会考虑诸如学生的学习时间、之前的考试成绩和出勤率等因素，以确定通过考试的可能性。

• 决策树模型：这些模型用于根据树状结构进行预测。可以将其想象为预测的决策树。你从顶部开始，根据已知特征跟随分支。在每个分支上，你根据一个特征做出决定，并继续前进，直到在叶子节点达到最终的预测。这是一个逐步的过程，用于找到最可能的结局。

• 随机森林模型：这些是决策树的集合。一组决策树协同工作。每棵树都在数据的不同部分上训练。为了做出预测，所有树都给出它们的答案，并将它们的预测平均以得到最终结果。这就像汇集了多棵树的看法，以做出更准确的猜测。

• 梯度提升模型：这些也是决策树的集成，这些是共同工作的决策树组。在这里，与随机森林模型不同，树是依次训练的，并且每一棵树都试图纠正前一棵树的错误。它们从彼此的错误中学习，并作为一个团队变得更好。这就像一个学习过程，它们不断改进，直到它们一起做出好的预测。

• 神经网络模型：这些是复杂的多层模型，能够学习数据中的复杂模式。这些模型能够学习数据中的复杂模式。它们通过信息分析的过程运行，发现类似于人脑中相互连接的神经元的功能。通过广泛的训练和接触多样化的数据集，模型提高了其解析复杂模式的能力，使其擅长在新数据中揭示复杂的关系。

• 支持向量机（SVMs）：SVMs 是强大的分类器，就像极其聪明的分隔器。想象一个三维空间，其中有点代表不同的事物。SVMs 确定绘制线或平面（称为超平面）的最优方式，以完美地分隔两组不同的点。这就像它们拥有一种非凡的能力来找到完美的边界，确保两组点尽可能远地分开，例如绘制一条无形但完美无瑕的线，将每一边上的事物组织得井井有条。

这些只是 Amazon Redshift 中可以使用 BYOM 的模型类型的一些示例。一般来说，任何可以表示为模型工件集和预测函数的模型都可以在 Redshift 中使用 BYOM。

我们已经了解了 Redshift ML BYOM 及其优势。在下一节中，你将创建一个 BYOM 本地推理模型。

创建 BYOM 本地推理模型

使用 BYOM 本地推理，机器学习模型及其依赖项被打包成一组文件，并部署到存储数据的 Amazon Redshift，使用户能够对存储的数据进行预测。当在 Amazon SageMaker 平台上训练和创建模型时，会创建模型工件及其依赖项。通过直接将模型部署到 Redshift 服务，你不需要将数据通过网络移动到另一个服务。本地推理对于数据敏感或需要低延迟预测的场景非常有用。

让我们开始创建 BYOM 本地推理模型的工作。

创建本地推理模型

要创建 BYOM 本地推理模型，第一步涉及在 Amazon SageMaker 上训练和验证一个 Amazon SageMaker 模型。为此，我们将在 Amazon SageMaker 上训练和验证一个 XGBoost 线性回归机器学习模型。按照以下说明创建 Amazon SageMaker 模型：

github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone.ipynb

在遵循了前面 URL 提供的说明后，通过运行预测函数来验证模型。现在，让我们继续下一步。在成功生成预测后，我们将创建 Redshift ML 模型。使用相同的笔记本，让我们运行一些命令来设置一些参数。

在 Redshift 上创建模型并运行预测

现在通过运行预测函数来验证模型。

在 SageMaker 中训练和验证了模型后，现在是时候将其导入到 Redshift 中。在下一节中，我们将使用相同的 SageMaker 笔记本设置构建 Redshift CREATE MODEL语句所需的参数。你将使用此语句在 Query Editor v2 中创建你的 Redshift ML 模型，使你能够使用集成的 SageMaker 模型在 Redshift 集群中存储的数据上执行本地推理。

设置参数

在设置参数之前，请在 Query Editor v2 中运行以下命令以创建本章的架构：

Create schema chapter11_byom;

此过程的第一个步骤是设置以下参数值：

• S3_BUCKET用于存储 Redshift ML 工件。

• MODEL_PATH是 Amazon SageMaker 模型工件在 S3 的位置。可选地，你可以使用 Python 中的print函数打印model_data并查看工件位置。

• REDSHIFT_IAM_ROLE是集群角色：

#provide your s3 bucket here
S3_BUCKET='Redshift ML s3 bucket name'
#provide the model path, this is coming from the model_data parameter
MODEL_PATH=model_data
#Provide Redshift cluster attached role ARN
REDSHIFT_IAM_ROLE = 'Redshift Cluster IAM Role'

接下来，我们将生成你将在 Redshift 上运行的CREATE MODEL语句。

生成 CREATE MODEL 语句

在 Jupyter 笔记本中执行此处提供的代码以自动生成CREATE MODEL语句：

sql_text=("drop model if exists predict_abalone_age; \
 CREATE MODEL chapter11_byom.predict_abalone_age \
FROM '{}' \
FUNCTION predict_abalone_age ( int, int, float, float,float,float,float,float,float) \
RETURNS int \
IAM_ROLE '{}' \
settings( S3_BUCKET '{}') \
")
print (sql_text.format(model_data,REDSHIFT_IAM_ROLE, S3_BUCKET))

前述语句的输出是你要在 Query Editor v2 中运行的CREATE MODEL语句。请复制该语句并前往 Query Editor v2 以执行剩余步骤。

在 Redshift 上运行本地推理

下面是CREATE MODEL语句。你应该生成一个类似的语句，其中FROM、IAM_ROLE和S3_BUCKET有不同的值：

CREATE MODEL chapter11_byom.predict_abalone_age
FROM 's3://redshift-ml-22-redshiftmlbucket-1cckvqgktpfe0/sagemaker/DEMO-xgboost-abalone-default/single-xgboost/DEMO-xgboost-regression-2022-12-31-01-45-30/output/model.tar.gz'
FUNCTION predict_abalone_age ( int, int, float, float,float,float,float,float,float) RETURNS int IAM_ROLE 'arn:aws:iam::215830312345:role/spectrumrs'
settings( S3_BUCKET 'redshift-ml-22-redshiftmlbucket-1cckvqgktpfe0') ;

在前面的命令中，FROM子句以model_data作为输入，其中包含 SageMaker 模型工件。当运行此命令时，Amazon Redshift ML 编译模型，将其部署到 Redshift，并创建一个predict_abalone_age预测函数，该函数用于 SQL 命令以在 Redshift 中本地生成预测。

一旦完成CREATE MODEL语句，你可以使用show model命令来查看模型的状态：

show model chapter11_byom.predict_abalone_age;

下面是输出结果：

图 11.1 – 本地推理模型元数据

注意模型状态为就绪，S3 模型路径是我们创建模型时给出的。推理类型为本地，这意味着模型类型是本地推理。

我们已成功创建本地推理模型；现在，让我们准备一个测试数据集以测试本地推理是否运行无任何问题。

数据准备

将测试数据从 S3 存储桶加载到 Redshift 表以测试我们的本地推理模型。

注意

请更新IAM_ROLE。不要更改 S3 存储桶位置。

运行以下命令创建表并加载数据：

drop table if exists chapter11_byom.abalone_test;
create table chapter11_byom.abalone_test
(Rings int, sex int,Length_ float, Diameter float, Height float, WholeWeight float, ShuckedWeight float,VisceraWeight float, ShellWeight float );
copy chapter11_byom.abalone_test
from 's3://jumpstart-cache-prod-us-east-1/1p-notebooks-datasets/abalone/text-csv/test/'
IAM_ROLE 'arn:aws:iam::212330312345:role/spectrumrs'
csv ;

对测试表进行采样以确保数据已加载：

select * from chapter11_byom.abalone_test limit 10;

这里是样本数据集：

图 11.2 – 显示测试数据集的样本记录

现在我们已加载测试数据，让我们运行SELECT命令，该命令调用predict_abalone_age函数。

推理

现在，调用作为CREATE MODEL语句一部分创建的预测函数：

Select original_age, predicted_age, original_age-predicted_age as Error
From(
select predict_abalone_age(Rings,sex,
Length_ ,
Diameter ,
Height ,
WholeWeight ,
ShuckedWeight ,
VisceraWeight ,
ShellWeight ) predicted_age, rings as original_age
from chapter11_byom.abalone_test ) a;

这是使用本地推理生成的预测结果的输出：

图 11.3 – 显示实际值与预测值

我们已成功训练和验证了一个 SageMaker 模型，并将其部署到 Redshift ML。我们还使用本地推理函数生成了预测。这展示了 Redshift 的 BYOM 本地推理功能。

在下一节中，您将了解 BYOM 远程推理功能。

使用 SageMaker 端点进行远程推理的 BYOM

在本节中，我们将探讨如何为 Amazon SageMaker Random Cut Forest 模型创建一个 BYOM 远程推理。这意味着您正在引入自己的机器学习模型，该模型在 Redshift 之外的数据上训练，并使用它通过端点对存储在 Redshift 集群中的数据进行预测。在此方法中，要使用 BYOM 进行远程推理，需要训练一个机器学习模型，在 Amazon SageMaker 中创建一个端点，然后使用 Amazon Redshift ML 扩展提供的 SQL 函数从 Redshift 查询中访问该端点。

当 Redshift ML 原生不支持模型时，此方法很有用，例如 Random Cut Forest 模型。您可以在此处了解更多关于 Random Cut Forest 的信息：tinyurl.com/348v8nnw。

为了演示此功能，您首先需要遵循此笔记本中的说明（github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/random_cut_forest/random_cut_forest.ipynb）使用 Amazon SageMaker 创建一个用于检测异常的随机切割森林机器学习模型。请完成 Amazon SageMaker 模型训练并验证模型，以确保端点正在运行，然后继续下一部分。

创建 BYOM 远程推理

一旦您验证了 SageMaker 端点已部署且运行正常，让我们在 Redshift 中通过指定 SageMaker 端点定义一个 CREATE MODEL 参考点。使用相同的笔记本，让我们在 Jupyter 中构建 CREATE MODEL 语句并运行它。

设置参数

让我们先设置参数：

• S3_Bucket 用于存储 Redshift ML 工件

• SAGEMAKER_ENDPOINT 是 SageMaker 侧的模型端点，用于运行推理

• REDSHIFT_IAM_ROLE 是集群角色：

REDSHIFT_IAM_ROLE = 'arn:aws:iam::215830312345:role/spectrumrs'
SAGEMAKER_ENDPOINT = rcf_inference.endpoint

注意

请使用您的 Redshift 集群角色更新 REDSHIFT_IAM_ROLE。

生成 BYOM 远程推理命令

让我们通过运行以下代码生成 CREATE MODEL 语句：

sql_text=("drop model if exists chapter11_byom.remote_random_cut_forest;\
CREATE MODEL chapter11_byom.remote_random_cut_forest\
 FUNCTION remote_fn_rcf (int)\
 RETURNS decimal(10,6)\
 SAGEMAKER'{}'\
 IAM_ROLE'{}'\
")
print(sql_text.format(SAGEMAKER_ENDPOINT,REDSHIFT_IAM_ROLE))

您已完成 Jupyter 笔记本的工作。现在您在 Amazon SageMaker 中有一个预训练模型，下一步是将它带入 Redshift ML。为此，访问查询编辑器 v2，连接到无服务器端点，并运行以下命令。

在查询编辑器 v2 中，运行以下命令：

CREATE MODEL chapter11_byom.remote_random_cut_forest
FUNCTION remote_fn_rcf (int) RETURNS decimal(10,6)
SAGEMAKER'randomcutforest-2022-12-31-03-48-13-259'
IAM_ROLE'arn:aws:iam:: 215830312345:role/spectrumrs'
;

通过运行 show model 命令检索模型元数据：

show model chapter11_byom.remote_random_cut_forest;

输出如下：

图 11.4 – 远程推理模型元数据

注意，在模型元数据中，模型状态参数设置为 READY，表示模型已部署。端点名称为 randomcutforest-2022-12-31-03-48-13-259。推理类型设置为 远程推理。当运行此模型时，Redshift ML 将存储在 Redshift 中的数据批量发送到 SageMaker，在那里生成推理。生成的预测值随后被发送回 Redshift，最终呈现给用户。

我们已成功部署模型。在下一节中，我们将运行预测。

数据预处理脚本

以下代码片段显示了您需要在 Redshift 上运行的预处理脚本。我们将创建用于运行推理的表：

COPY chapter11_byom.rcf_taxi_data
FROM 's3://sagemaker-sample-files/datasets/tabular/anomaly_benchmark_taxi/NAB_nyc_taxi.csv'
IAM_ROLE 'arn:aws:iam::215830312345:role/spectrumrs' ignoreheader 1 csv delimiter ',';

注意

请使用您附加到 Redshift 集群的 IAM 角色更新 IAM_ROLE 参数。

样本数据以确保数据已加载：

select * from chapter11_byom.rcf_taxi_data limit 10;

这是输出：

图 11.5 – 显示测试数据集的样本记录

现在我们有了远程推理端点和测试数据集，让我们调用预测函数。

计算异常分数

现在，让我们从整个出租车数据集中计算异常分数：

select ride_timestamp, nbr_passengers, chapter11_byom.remote_fn_rcf(nbr_passengers) as score
from chapter11_byom.rcf_taxi_data;

下面的输出是远程推理预测的结果：

图 11.6 – 显示远程函数预测值

前面的输出显示了不同日期的异常分数和乘客数量。

在下面的代码片段中，我们将打印出任何得分大于 3 且标准差（大约是平均得分的 99.9 百分位）的数据点：

with score_cutoff as
(select stddev(chapter11_byom.remote_fn_rcf(nbr_passengers)) as std, avg(chapter11_byom.remote_fn_rcf(nbr_passengers)) as mean, ( mean + 3 * std ) as score_cutoff_value
From chapter11_byom.rcf_taxi_data)
select ride_timestamp, nbr_passengers, chapter11_byom.remote_fn_rcf(nbr_passengers) as score
from chapter11_byom.3rcf_taxi_data
where score > (select score_cutoff_value from score_cutoff)
;

输出如下：

图 11.7 – 显示不可接受的异常分数

在前面的结果中，我们看到某些天的乘客量远远高于我们的远程推理函数，并将它们标记为异常。这标志着将远程推理模型引入 Redshift 的部分结束。

摘要

在本章中，我们讨论了 Amazon Redshift ML BYOM 在本地和远程推理方面的优势和用例。我们创建了两个 SageMaker 模型，然后将它们导入 Redshift ML 作为本地推理和远程推理模型类型。我们在 Redshift 中加载了测试数据集，然后运行了预测函数并验证了这两种类型。这展示了 Redshift 如何简化并赋予商业社区使用外部创建的模型进行数据推理的能力。这种方法加快了在 Redshift 外部创建的机器学习模型交付给数据仓库团队的速度。

在下一章中，你将了解 Amazon Forecast，它使你能够使用 Redshift ML 进行预测。

第十二章：数据仓库中的时序预测

在前面的章节中，我们讨论了如何使用 Amazon Redshift 机器学习 (ML) 通过熟悉的 SQL 命令轻松创建、训练和应用 ML 模型。我们讨论了如何使用监督学习算法来解决分类或回归问题，以预测某种结果。在本章中，我们将讨论如何使用 Amazon Redshift 中的数据，通过 Amazon Forecast 预测某种未来的事件。

本章将介绍如何使用 Amazon Forecast (aws.amazon.com/forecast/) 进行 Amazon Redshift 上的时序预测，这是一个完全托管的时间序列预测服务，使用 SQL，无需移动数据或学习新技能。我们将引导你了解以下主题：

• 预测和时序数据

• 什么是 Amazon Forecast？

• 配置和安全

• 使用 Redshift ML 创建预测模型

技术要求

本章需要网络浏览器和以下访问权限：

• AWS 账户

• Amazon Redshift

• Amazon Redshift 查询编辑器 v2

你可以在这里找到本章使用的代码：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/blob/main/CodeFiles/chapter12/chapter-12.sql.

预测和时序数据

预测是一种估计未来事件的方法，它涉及分析历史数据和过去模式，以推导出未来的可能结果。例如，基于历史数据，企业可以预测其销售收入或确定下一个时间段将发生什么。

预测在指导企业做出关于其运营和优先事项的明智决策中发挥着重要作用。许多组织依赖如 Amazon Redshift 这样的数据仓库，对大量历史和当前数据进行深度分析，从而推动他们的业务目标并衡量未来的成功。作为规划工具，预测通过利用过去的模式帮助企业为未来的不确定性做准备，其基本原理是过去发生的事情很可能会在未来再次发生。这些预测基于在给定时间段内对观察结果的分析。

下面是一些组织如何使用预测的例子：

• 财务规划

• 供需计划

• 定时推出新产品或服务

• 资源规划

• 预测未来事件，如销售和收入收益

• 审查管理决策

通过观察趋势图可以帮助我们预测趋势，但时间序列预测可以给我们一个更好的估计，了解它可能如何继续。我们还可以对那些在时间上没有明显模式或趋势的数据进行建模。当存在模式时，我们可以查看数据的整个历史来了解它之前是如何发生的。如果没有模式，我们可以更多地依赖最近的数据进行预测。

预测方法的类型

预测方法有两种：定性和定量。

让我们看看定性和定量方法是什么，如aws.amazon.com/what-is/forecast/中定义的：

• 定性预测是主观的，依赖于市场营销专家的意见来做出预测。当没有足够的历史数据时，可以使用这些方法。定性预测方法的例子包括市场研究，如民意调查和调查，以及德尔菲法来收集有见地的意见并预测趋势。

• 定量预测在本质上具有客观性，用于预测长期未来趋势。它使用历史和当前数据来预测未来趋势。定量预测方法的例子包括时间序列预测、计量经济学建模和指标方法。

在本章中，我们将专注于使用时间序列进行定量预测，也称为时间序列预测。现在，让我们来看看时间序列预测是什么。

什么是时间序列预测？

时间序列预测是一种数据科学技术，它使用机器学习来研究历史数据并预测时间序列数据中的未来趋势或行为。时间序列数据在许多情况下都得到应用，如天气预报、金融研究、统计学、资源规划和计量经济学。在前一章中，我们探讨了回归模型，使用横截面数据来预测值，其中输入变量用于确定变量之间的关系，以便您可以在没有目标变量的数据集上预测未知的目标。

这种数据是独特的，因为它按时间顺序排列数据点。时间序列数据可以绘制在图上，这些图是可视化和分析数据的宝贵工具。在许多组织中，数据科学家或数据分析师使用这些图来识别预测数据特征或属性。让我们来看看时间序列数据特性的例子。

时间趋势数据

在趋势数据中，观测值是在相等的时间间隔内捕获的。在时间序列图中，y轴始终是时间单位，如季度、年、月、日、小时、分钟或秒。在图 12.1中，我们有按年计算的总订户趋势的例子：

图 12.1 – 每年总订户的趋势

季节性

在季节性观察中，我们可以看到随时间变化的周期性波动，这些波动是可预测的，因为我们根据历史模式理解了行为和原因。例如，零售商知道在特定的假日期间销售额会增加。在图 12.2中，我们看到 11 月和 12 月的销售额出现上升趋势，这是由于假日季节的预期：

图 12.2 – 由于假日季节导致的向上峰值

结构中断

在结构中断中，我们有一些不太可预测的波动，这些波动可能在任何时间点发生。例如，在经济衰退或地缘政治动荡期间，一个国家的经济状况可能会出现结构中断。在图 12.3中，我们可以看到随时间推移的经济增长可视化。下降表示在特定数据点发生的事件；例如，2009 年的那个与美国的抵押贷款危机相关。

图 12.3 – 随时间推移的经济增长

让我们来看看 Amazon Redshift ML 是如何使用 Amazon Forecast 来生成时间序列数据集的模型的。

亚马逊预测是什么？

亚马逊预测，就像 Amazon Redshift ML 一样，使用它不需要机器学习经验。时间序列预测是通过基于历史数据的各种机器学习和统计算法生成的。作为用户，你只需将数据发送到 Amazon Forecast，它将检查数据并自动识别什么是有意义的，并生成预测模型。

使用 Amazon Redshift ML，你可以利用 Amazon Forecast 从你的时间序列数据创建和训练预测模型，并使用这些模型生成预测。对于预测，我们需要一个目标时间序列数据集。在目标时间序列预测中，我们使用过去的数据或先前值来预测变量的未来值，这通常被称为单变量时间序列，因为数据在相等的时间增量上是顺序的。目前，Redshift ML 支持具有自定义域的目标时间序列数据集。你的数据仓库中的数据集必须包含你捕获数据的频率或间隔。例如，你可能每小时记录和汇总平均温度。

亚马逊预测会根据算法自动训练你的模型，该算法使用 Auto ML，并提供六个内置算法（要了解更多关于内置算法的信息，请参阅此资源：docs.aws.amazon.com/forecast/latest/dg/aws-forecast-choosing-recipes.html#forecast-algos)。这些预测模型，称为预测器，是通过从 Amazon Redshift 中的时间序列数据中最佳组合这些算法创建的。

配置和安全

由于 Amazon Forecast 是一个独立的完全托管服务，您需要创建或修改您的 IAM 角色，以包括对您的无服务器端点或 Redshift 集群的访问权限。此外，您应该在 IAM 角色中配置 Amazon Forecast（forecast.amazonaws.com）的信任关系，以启用必要的权限。

您可以使用AmazonForecastFullAccess托管策略，该策略授予对 Amazon Forecast 及其所有支持的操作的完全访问权限。您可以将此策略附加到默认角色，但在您的生产环境中，您必须遵循最小权限原则。您可以使用更严格的权限，例如以下内容：

 {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "forecast:DescribeDataset",
                "forecast:DescribeDatasetGroup",
                "forecast:DescribeAutoPredictor",
                "forecast:CreateDatasetImportJob",
                "forecast:CreateForecast",
                "forecast:DescribeForecast",
                "forecast:DescribeForecastExportJob",
                "forecast:CreateMonitor",
                "forecast:CreateForecastExportJob",
                "forecast:CreateAutoPredictor",
                "forecast:DescribeDatasetImportJob",
                "forecast:CreateDatasetGroup",
                "forecast:CreateDataset",
                "forecast:TagResource",
                "forecast:UpdateDatasetGroup"
            ],
            "Resource": "*"
        } ,
    {
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource":"arn:aws:iam::<aws_account_id>:role/service-role/<Amazon_Redshift_cluster_iam_role_name>"
    }
    ]
}

使用 Redshift ML 创建预测模型

目前，如果您需要在您的数据仓库中执行预测，您需要将数据集导出到外部系统，然后应用预测算法来创建输出数据集，然后再将它们导入数据仓库以供您的表示层或进一步分析。通过 Redshift ML 与 Amazon Forecast 的集成，您无需执行所有这些步骤。现在，您可以直接在数据仓库中的数据集上创建预测模型。

在第五章中，我们讨论了基本的CREATE MODEL语法及其结构。让我们看看预测的CREATE MODEL语法：

CREATE MODEL forecast_model_name
FROM { table_name | ( select_query ) }
TARGET column_name
IAM_ROLE { default | 'arn:aws:iam::<AWS account-id>:role/<role-name>' }
AUTO ON MODEL_TYPE FORECAST
[ OBJECTIVE optimization_metric ]
SETTINGS (S3_BUCKET 'bucket',
          HORIZON integer,
          FREQUENCY forecast_frequency,
          [, PERCENTILES perc_comma_delim_string],
          [ S3_GARGABE_COLLECT OFF ])

在创建预测模型的CREATE MODEL语句中，有几个需要注意的事项。

首先，预测模型不会创建推理函数。这样做的原因是，当我们使用 Amazon Forecast 训练预测器时，我们在训练请求中指定了未来想要进行的预测的数量（HORIZON）和频率（FREQUENCY）。正因为如此，一个训练好的模型有一个固定的预测，所以没有物理模型可以编译和执行。一个自定义的 CTAS 命令（稍后将讨论）用于从 S3 中的训练输出位置提取预测，并将其导入到 Redshift 中的本地表中。

接下来，我们可以指定可选的目标或优化指标，该指标用于优化预测模型的欠预测和过预测。Amazon Forecast 提供了不同的模型准确度指标，供您评估您的预测模型强度，这些指标在此列出：

• AverageWeightedQuantileLoss – 在指定的分位数上衡量模型的准确性

• WAPE（加权绝对百分比误差）- 衡量预测值与观测值之间的总体偏差

• RMSE（均方根误差）- 平方误差平均值的平方根

• MASE（平均绝对缩放误差）- 通过将平均误差除以缩放因子来计算

• MAPE（平均绝对百分比误差）- 对每个时间单位观测值与预测值之间的百分比误差取绝对值，然后平均这些值

最后，重要的是要注意，FORECAST不支持任何超参数。相反，任何FORECAST特定的训练设置将使用SETTINGS子句指定。目前支持的设置如下：

• FREQUENCY：预测中的预测粒度。有效值是Y（年）、M（月）、W（周）、D（日）、H（小时）和min（分钟），例如，H表示每小时预测或1min表示每分钟预测）。

• HORIZON：预测未来时间步数的数量（例如，24）。

注意

FREQUENCY H和HORIZON 24表示您希望对下一天进行每小时预测。

• PERCENTILES（可选）：预测类型用于训练预测器。最多可以指定五种预测类型或百分位数。这些类型可以是分位数 [0.01 to 0.99] 或 mean。在0.50分位数处的预测将估计 50%的时间值较低。

现在，让我们看看一个用例，我们可以使用目标时间序列数据集来预测目标预测值。

业务问题

对于这个用例，让我们以一个在线零售商店为例，预测商店中某些产品的未来需求。这个数据集来自 UCI ML 存储库，可在以下链接找到：archive.ics.uci.edu/dataset/352/online+retail。为了这个练习，我们对数据进行修改，使其更接近目标时间序列数据集，包含item_id、date和target_value字段。数据跨度为两年，从 2018 年 12 月到 2020 年 11 月。修改后的数据包含商品名称、销售日期和销售产品总数。

数据集引用

Online Retail. (2015). UCI Machine Learning Repository. doi.org/10.24432/C5BW33。

上传和分析数据

成功连接到 Redshift 作为管理员或数据库开发者后，将数据加载到 Amazon Redshift，并遵循此处概述的步骤：

1. 导航到查询编辑器 v2，连接到无服务器端点，并连接到开发数据库：

图 12.4 – 连接到开发数据库

1. 执行以下步骤以创建模式和贸易详情表并加载数据：

   CREATE SCHEMA chapter12_forecasting;
   

   Create table chapter12_forecasting.web_retail_sales
   

   (invoice_Date date, item_id varchar(500), quantity int);
   

   COPY chapter12_forecasting.web_retail_sales
   

   FROM 's3://packt-serverless-ml-redshift/chapter12/web_retail_sales.csv'
   

   IAM_ROLE default
   

   FORMAT AS CSV
   

   DELIMITER ','
   

   IGNOREHEADER 1
   

   DATEFORMAT 'YYYY-MM-DD'
   

   REGION AS 'eu-west-1';
   

2. 运行以下查询以检查一些样本数据：

   select * from chapter12_forecasting.web_retail_sales;
   

结果将类似于以下内容：

图 12.5 – 查询结果

如您在前面的图中所见，我们有以下内容：

• invoice_date（销售商品时的日期）

• item_id（销售产品的名称）

• quantity（每天该产品销售的数量）

使用此数据集，我们将在 Amazon Forecast 中创建一个模型，并预测给定产品的未来需求。目标是分析特定产品在接下来五天的需求将如何。为了准确性和验证，我们将使用截至 2020 年 10 月的数据创建模型。一旦我们有预测器准备就绪，我们将将其输出值与 2020 年 11 月实际值进行比较，以确定我们模型的准确性。我们还将查看不同的准确度指标，如平均加权分位数损失（wQL）、WAPE、MAPE、MASE 和 RMSE。

让我们使用我们在“使用 Redshift ML 创建预测模型”部分开头讨论的CREATE MODEL语句来创建模型。

Objective设置为AverageWeightedQuantileLoss（wQL 的平均值），这是optimization_metric的准确度指标。Frequency设置为D（天数），Horizon设置为5，Percentiles设置为0.25、0.50、0.75、0.90和mean。

如果您没有指定百分位数设置，那么 Forecast 将在p10、p50和p90（0.10、0.50 和 0.90）上生成预测。

在查询编辑器 v2 中运行以下命令以创建模型。请注意，这大约需要 90 分钟。

CREATE MODEL forecast_sales_demand
FROM (select item_id, invoice_date, quantity from  chapter12_forecasting.web_retail_sales where invoice_date <  '2020-10-31')
TARGET quantity
IAM_ROLE 'arn:aws:your-IAM-Role'
AUTO ON MODEL_TYPE FORECAST
OBJECTIVE 'AverageWeightedQuantileLoss'
SETTINGS (S3_BUCKET '<<bucket name>>',
 HORIZON 5,
 FREQUENCY 'D',
 PERCENTILES '0.25,0.50,0.75,0.90,mean',
 S3_GARBAGE_COLLECT OFF);

运行SHOW MODEL命令以查看模型训练是否完成：

SHOW MODEL forecast_sales_demand;

结果如下：

图 12.6 – 模型训练结果

您还可以使用Amazon Forecast的值查看预测器的状态。

点击查看数据集组，并通过粘贴redshiftml_20221224001451333090来查找数据集组名称。

点击此数据集组名称，验证目标时间序列数据是否为激活状态，如图12.7所示。

您还可以通过点击查看来查看有关您的时间序列数据的详细信息，包括数据文件中注册的数据频率、数据集导入详情等。

图 12.7 – 验证目标时间序列数据的状态

一旦激活，您可以通过点击查看预测器来查看预测器。预测器对话框将显示训练状态，如下所示：

图 12.8 – 视觉预测器的训练状态

再次运行SHOW MODEL命令以查看模型训练是否完成：

SHOW MODEL forecast_sales_demand;

结果如下：

图 12.9 – 模型训练完成状态

一旦模型训练完成并准备就绪，您可以通过在您的预测上创建一个表来查看输出：

对于一家零售店，公司需要确保他们不会过度预测或低估预测所需数量，以便有效地管理库存并提高利润。如前所述，Amazon Forecast 与 Redshift ML 提供不同的优化指标，可以用来衡量在不同分位数上指定的模型的准确性。对于此用例，我们为0.25、0.50、0.75、0.90和mean创建了模型。如果重点是过度预测，那么对于零售商来说，选择更高的分位数（0.90）可以更好地捕捉高需求商品或产品的需求高峰。这表明产品满足预测需求有 90%的成功概率。现在，让我们看看如何获取我们的预测结果。

创建包含输出结果的表格

在模型完成训练并准备就绪后，我们现在使用简单的 CTAS 命令在我们的模式中创建一个表格来存储所有预测结果，如下所示：

create table chapter12_forecasting.tbl_forecast_sales_demand as SELECT
FORECAST(forecast_sales_demand);

在此命令中，forecast()是一个伪表函数，它接受你的模型名称作为输入参数。然后，数据从你的模型结果存储在 S3 存储桶位置中提取。

通过运行以下 SQL 命令查看前一个表格的输出：

select * from chapter12_forecasting.tbl_forecast_sales_demand;

查看图 12.10。你可以看到，对于每一天，预测为每个我们提供的分布点或分位数以及平均值生成了输出预测：

图 12.10 – 表格输出

对于需求量高的产品，零售商可以选择更高的分位数，例如0.90（p90），这能更好地捕捉需求高峰，而不是在平均值或0.50分位数进行预测。

现在，让我们看看一款热门产品的数据：JUMBO BAG RED RETROSPOT。

运行以下 SQL 查询：

select a.item_id as product,
a.invoice_date,
a.quantity as actual_quantity ,
p90::int as p90_forecast,
p90::int - a.quantity as p90_error ,mean::int,
p50::int as p50_forecast
from chapter12_forecasting.web_retail_sales a
inner join chapter12_forecasting.tbl_forecast_sales_demand b
on upper(a.item_id) = upper(b.id)
and a.invoice_date = to_date(b.time, 'YYYY-MM-DD')
AND a.item_id = 'JUMBO BAG RED RETROSPOT'
where invoice_date > '2020-10-31'
order by 1,2;

这是结果：

图 12.11 – 预测数据

为了可视化数据，选择invoice_date属性，并在Y轴上选择p90_forecast：

图 12.12 – 预测图表

如果我们仔细查看图 12.11 中的前述数据，我们可以观察到第 1 行被低估了，而第 2 行和第 3 行非常接近实际值，第 4 行只是略微高估了。为了测试预测，你可以进一步使用不同的数据集或甚至在不同分位数上进行测试。此外，零售商可以使用这些数据为不同产品，如低需求产品，并使用其他分位数，如p50或mean。

wQL 用于计算AverageWeightedQuantileLoss指标。wQL 可用于管理过度预测和不足预测的成本。这些指标将在 Amazon Forecast 控制台中对您的预测器可用。通常，要计算0.90的 wQL，将p90误差字段中正值的总和乘以较小的权重0.10，并将p90误差中负值的绝对值相加，乘以0.90。

为了与您的业务成果保持一致，您可以在 Amazon Redshift 数据仓库中创建不同分位数（百分位数）的预测模型。这为您提供了灵活性，以衡量您的业务目标，并保持成本影响在较低水平。

摘要

在本章中，我们讨论了如何使用 Redshift ML 通过创建用于预测的Model_Type模型来生成 Amazon Forecast 的预测模型。您了解了预测是什么以及如何使用时间序列数据生成不同分位数的不同模型。我们还探讨了不同的分位数，并简要介绍了不同的优化指标。

我们展示了如何使用预测模型来预测零售用例的未来销售数量，以及如何使用它们来平衡过度预测和不足预测的影响。

在下一章中，我们将探讨操作和优化方面的考虑。

第十三章：实施和优化 Amazon Redshift 机器学习模型

现在您已经学会了如何创建许多不同类型的机器学习模型，我们将向您展示如何实施您的模型训练管道。一旦您的模型投入生产，您希望定期刷新模型并自动化此过程。此外，定期评估您的模型以维护和提升其准确性也很重要。

在本章中，我们将讨论以下主要主题：

• 实施您的机器学习模型

• 优化 Redshift 模型以提高准确性

技术要求

本章需要网络浏览器以及访问以下内容：

• 一个 AWS 账户

• 一个 Amazon Redshift 无服务器端点

• Amazon Redshift 查询编辑器 v2

• 一个 Amazon EC2 Linux 实例（可选）

您可以在此处找到本章中使用的代码：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/.

实施您的机器学习模型

一旦模型经过验证并定期用于运行预测，它应该被实施。这样做的原因是消除重新训练模型的手动任务，并确保在数据分布随时间变化后，您的模型仍然保持高精度，也称为数据漂移。当发生数据漂移时，您需要使用更新的训练集重新训练模型。

在以下章节中，我们将进行简单的模型重新训练，然后向您展示如何从现有模型创建版本。

无版本控制的模型重新训练过程

为了演示重新训练过程，我们将使用我们之前使用的一个模型。

在第七章中，我们讨论了不同的回归模型，因此让我们使用 chapter7_regressionmodel.predict_ticket_price_auto 模型。该模型解决了一个多输入回归问题，SageMaker Autopilot 选择了 XGBoost 算法。

假设这个模型表现良好，并且根据我们的数据加载过程，我们希望每周重新训练此模型。

要重新训练此模型，我们必须首先删除现有模型，然后按照以下方式重新执行 CREATE MODEL 命令：

DROP MODEL chapter7_RegressionMOdel.predict_ticket_price_auto;
CREATE MODEL chapter7_RegressionMOdel.predict_ticket_price_auto from
chapter7_RegressionModel.sporting_event_ticket_info_training
TARGET final_ticket_price
FUNCTION predict_ticket_price_auto
IAM_ROLE default
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (s3_bucket <<'your-S3-bucket>>',
s3_garbage_collect off,
max_runtime 9600);

您可以使用各种技术设置定期运行，这包括使用查询编辑器 v2 的调度功能或运行脚本。有关使用查询编辑器 v2 调度查询的更多信息，请参阅以下内容：

docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-schedule-query.html.

带版本控制的模型重新训练过程

这种简单地删除和重新创建模型的方法在某些情况下可能可行，但由于我们只是删除和重新创建模型，因此没有模型历史记录。这使得将新训练的模型与之前的版本进行比较变得非常困难，甚至不可能。

在撰写本文时，Redshift ML 没有原生版本控制功能。然而，您仍然可以通过实现一些简单的 SQL 技巧并利用自带模型（BYOM）功能来进行版本控制，这些内容您可以在第十一章中了解到。

BYOM 非常适合利用预构建的 Amazon SageMaker 模型，以便在 Amazon Redshift 中运行推理查询，您还可以使用 BYOM 对使用 Redshift ML 构建的模型进行操作，这意味着我们可以创建一个由 Redshift ML 创建的现有模型的 版本。

让我们快速回顾一下 BYOM 的语法，用于本地推理：

CREATE MODEL model_name
    FROM ('job_name' | 's3_path' )
    FUNCTION function_name ( data_type [, ...] )
    RETURNS data_type
    IAM_ROLE { default }
    [ SETTINGS (
      S3_BUCKET 'bucket', | --required
      KMS_KEY_ID 'kms_string') --optional
    ];

我们需要作业名称、模型输入的数据类型和输出。我们可以通过在现有模型上运行 SHOW MODEL 语句来获取 CREATE MODEL 语句所需的信息。在 Query Editor v2 中运行以下命令：

SHOW MODEL chapter7_regressionmodel.predict_ticket_price_auto;

结果如下：

图 13.1 – SHOW MODEL 输出

下面的 CREATE MODEL 语句用于使用 SHOW MODEL 命令创建当前模型的版本。您还需要在 FUNCTION 中包含来自 图 13.1 的函数参数类型，并包含 Target Column（FINAL_TICKET_PRICE）的数据类型。请注意，我们将日期（YYYYMMDD）附加到模型名称和函数名称的末尾以创建我们的版本。您可以在 Query Editor v2 中运行以下代码以创建模型的版本：

CREATE MODEL chapter7_regressionmodel.predict_ticket_price_auto_20230624
    FROM 'redshiftml-20221229211311236659'
    FUNCTION predict_ticket_price_auto_20230624 (float8,
        int8, varchar, timestamp, varchar, varchar,
        varchar, varchar, int8, int8, varchar, int8,
        float8, varchar)
    RETURNS float8
    IAM_ROLE default
    SETTINGS (
      S3_BUCKET '<<your S3 Bucket>>');

执行以下 SHOW MODEL 命令：

SHOW MODEL chapter7_regressionmodel.predict_ticket_price_auto_20230624;

在 图 13.2 中，请注意推理类型显示为本地，这表明这是带有本地推理的 BYOM：

图 13.2 – SHOW MODEL 输出

现在您已经学会了如何创建之前训练的 Redshift ML 模型的版本，我们将向您展示如何自动化此过程。

自动化创建模型语句进行版本控制

我们在此处包含了脚本：github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/CodeFiles/chapter13.

您可以使用这些脚本并根据需要对其进行自定义。这些脚本包含自动化模型版本控制过程所需的所有组件。本章的示例使用在 EC2 实例上运行的 Bash 脚本和 RSQL。如果您愿意，您也可以在 Windows 或 macOS 上安装 RSQL。

您可以在以下位置找到有关使用 RSQL 与 Amazon Redshift 交互的更多信息：docs.aws.amazon.com/redshift/latest/mgmt/rsql-query-tool-getting-started.html。

要下载本书的所有代码，您可以在运行 Linux 或 Windows 的 EC2 实例或您本地的 Windows 或 Mac 机器上运行以下链接中给出的命令：

github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift.git。

在运行脚本之前，我们需要创建用于生成模型版本CREATE MODEL命令所需的模式和表。您可以在查询编辑器 v2 中执行以下步骤：

1. 创建模式：

   Create schema chapter13;
   

2. 创建包含自动生成CREATE MODEL命令所需元数据的表：

   create table chapter13.local_inf_ml_model_components
   

   (model_name varchar(500),
   

   schema_name varchar(500),
   

   automlJobName varchar(500),
   

   functionName varchar(500),
   

   inputs_data_type varchar(500),
   

   target_column varchar(50),
   

   returns_data_type varchar(50),
   

   model_arn varchar (500),
   

   S3_Bucket varchar (200) );
   

3. 初始化local_inf_ml_components表。

注意，您只需初始化此表一次，包括模型名称、模式名称、我们预测的目标值的类型、IAM 角色的Amazon 资源名称（ARN）以及用于 Redshift ML 工件要使用的 S3 存储桶。该表将随着自动化脚本所需额外数据的更新而更新：

insert into chapter13.local_inf_ml_model_components
values
(
'predict_ticket_price_auto',
'chapter7_regressionmodel',
' ',' ',' ',' ','float8',
'<arn of your IAM ROLE>'
'<your S3 Bucket>)';

现在，我们已经准备好运行自动化脚本。图 13.3使用我们的predict_ticket_price_auto模型说明了此流程，该模型来自第七章。步骤 1通过使用 BYOM 并附加时间戳创建模型版本，步骤 2删除并创建新的模型：

图 13.3 – 自动化脚本步骤 1 和 2

让我们通过图 13.3中的步骤进行说明。

步骤 1 – 从现有模型创建版本

您可以参考位于github.com/PacktPublishing/Serverless-Machine-Learning-with-Amazon-Redshift/tree/main/CodeFiles/chapter13或您在运行git clone命令后放置文件的位置的step1_create_model_version.sh脚本。

step1_create_model_version.sh脚本的内容也显示在以下代码片段中。如您所见，它调用其他脚本和命令如下：

#! /bin/bash
# create SHOW MODEL sql command
./generate_show_model_sql.sh  'chapter7_regressionmodel.predict_ticket_price_auto'
#Read SHOW MODEL output and write to file
./show_model.sh
#copy SHOW MODEL output to the model info table
aws s3 cp create_model.txt s3://<your-s3-bucket>>
#load SHOW MODEL output and prep table to generate create model
./prep_create_model.sh
#generate sql to create model version
./generate_create_model_version_sql.sh
#execute the sql to create model verson
./execute_create_model_version.sh

在执行此脚本之前，请阅读以下子节，因为它们包含一些设置步骤的说明。

创建 show_model_sql 命令

我们有一个名为generate_show_model_sql.sh的简单脚本，其代码如下所示：

#!/bin/bash
modelname=$1
echo $1
echo SHOW MODEL $1 ';' > show_model.sql

此脚本将模型名称作为输入。在提供的脚本中，我们已经在step1_create_model_version.sh驱动脚本中提供了模型名称。您可以根据需要修改它。

该脚本创建一个写入名为show_model.sql的文件的SHOW MODEL命令，以便在show_model.sh脚本中读取。

读取 SHOW MODEL 输出并将其写入文件。

此步骤执行一个名为show_model.sh的 Amazon Redshift RSQL 脚本，该脚本读取show_model.sql文件并将输出写入名为create_model.txt的文件。

将 SHOW MODEL 输出复制到模型信息表中。

这将create_model.txt文件复制到 S3 存储桶中。

加载 SHOW MODEL 输出并准备表以生成CREATE MODEL。

此步骤执行另一个名为prep_create_model.sh的 Amazon Redshift RSQL 脚本，该脚本执行以下操作：

• 创建并加载model_info表。

• 从model_info表中更新local_inf_ml_model_components，以便可以生成用于模型版本的CREATE MODEL语句。

• 将生成的CREATE MODEL语句插入到create_model_sql表中。

生成创建模型版本的 SQL 语句。

此步骤调用一个名为generate_create_model_version_sql.sh的 Amazon Redshift RSQL 脚本，该脚本读取create_model表并将 SQL 写入名为model_version.txt的文本文件。

执行 SQL 以创建模型版本。

此步骤调用一个名为execute_create_model_version.sh的 Amazon Redshift RSQL 脚本，该脚本创建我们之前创建的模型的版本。

现在您可以根据模型版本删除和创建模型。

步骤 2 – 重新训练您的 Redshift ML 模型以从现有模型创建版本

此步骤调用一个名为retrain_model.sh的 Amazon Redshift RSQL 脚本，该脚本删除并创建我们的模型。它引用retrain_model.sql，您可以根据需要修改它。

现在您已经学会了如何自动化重新训练 Redshift ML 模型的过程，让我们讨论如何优化模型准确性。

优化 Redshift 模型准确性

在本节中，我们将回顾维护您模型最佳准确性的最佳实践。

您需要持续监控您的模型，以确保在模型训练运行之间分数保持稳定。考虑我们在这里创建的模型的新版本：

图 13.4 – 新模型输出

创建一个类似此表，并跟踪每周的均方误差（MSE）分数，从 SHOW MODEL 输出中获取：

CREATE TABLE chapter13.model_score_history (
    model_name character varying(500),
    schema_name character varying(500),
    score integer,
    variance integer,
    training_date date
)
DISTSTYLE AUTO;

方差将是模型连续版本分数的差异。

通过编写类似此查询来检查您的模型趋势：

Select model_name, score, variance, training_date
Order by model_name, training_date desc;

如果方差不在合理的范围内，您需要寻找提高模型分数的方法。

让我们探讨如何通过使用更多数据和尝试不同的模型类型和算法来提高模型质量。

模型质量

第一项最佳实践是使用更多数据来提高模型的质量。您还可以通过增加MAX_RUNTIME参数来为模型增加更多训练时间。

确保您使用的是具有代表性的训练数据集，并为验证创建至少 10%的样本。

尝试不同的模型类型和算法以获得最佳模型。例如，在第第七章中，我们为多输入回归模型尝试了两种不同的算法。在第一个中，我们尝试了线性学习，并得到了 MSE 分数为 701：

图 13.5 – 线性学习模型类型的 MSE 分数

当我们再次运行它而没有指定模型类型时，SageMaker Autopilot 选择了 XGBoost 作为模型类型，并给出了更好的 MSE 分数0.711260：

图 13.6 – XGBoost 模型类型的 MSE 分数

模型可解释性

第二个最佳实践是使用可解释性报告来更好地了解哪些输入到你的模型中承载了最多的权重。

在 Query Editor v2 中运行以下 SQL 命令：

select EXPLAIN_MODEL ('chapter7_regressionmodel.predict_ticket_price_auto')

这返回了用于训练模型的输入的 Shapley 值：

{"explanations":{"kernel_shap":{"label0":{"expected_value":23.878915786743165,"global_shap_values":
{"away_team":0.050692683450484,"city":0.004979335962039937,"event_date_time":0.05925819534780525,"event_id":0.31961543069587136,"home_team":0.04245607437910639,"list_ticket_price":36.364129559427869,"location":0.005178670063000977,"seat":0.011496876723927165,"seat_level":0.011342097571256795,"seat_row":0.011987498536296578,"seat_section":12.15498245617505,"sport":0.0029737602051575346,"ticket_id":0.3184045531012407,"ticketholder":0.005226471657467846}}}},
"version":"1.0"}

你会注意到list_ticket_price具有最高的值36.364 – 这意味着它是权重最高的输入。你可以通过移除模型训练中权重非常低的输入列来实验。检查通过移除不必要的训练输入列是否仍然得到相同的近似模型分数，并有助于提高训练时间。

概率

对于分类问题，利用生成的内置函数，你可以看到给定预测的概率。有关此功能的详细示例，请参阅第五章。

现在我们来看看由 Amazon SageMaker Autopilot 生成的有用笔记本。

使用 SageMaker Autopilot 笔记本

你的 Autopilot 作业生成一个数据探索笔记本和一个候选定义笔记本。要查看这些笔记本，请按照以下步骤操作：

1. 在 AWS 控制台中，搜索SageMaker，然后选择Amazon SageMaker：

图 13.7 – 选择 Amazon SageMaker

1. 然后，选择Studio：

图 13.8 – 选择 Studio

1. 接下来，选择Open Studio：

图 13.9 – 选择 Open Studio

1. 接下来，选择AutoML：

图 13.10 – 选择 AutoML

选择AutoML后，以下屏幕将显示：

图 13.11 – 模型名称列表

1. 选择你想要评估的模型名称。你可以通过使用SHOW MODEL输出的 AutoML 作业名称来获取它。在这个例子中，我在predict_ticket_price_auto模型上使用了SHOW MODEL：

图 13.12 – SHOW MODEL 输出

你将看到如下输出：

图 13.13 – AutoML 最佳模型

在图 13.13 中，您可以查看已训练的模型列表，其中最佳模型被突出显示。这还显示了Mse的目标、值以及所使用的算法，并且有链接可以查看模型详情、候选生成笔记本和数据探索笔记本。

1. 点击查看模型详情 – 这是您查看特征重要性或可解释性的另一种方式：

图 13.14 – 特征重要性

您还可以查看 SageMaker Autopilot 使用的超参数：

图 13.15 – 超参数

1. 现在，尝试点击打开数据 探索笔记本：

图 13.16 – 数据探索报告

这将向您展示数据探索报告，您可以看到诸如目标分析、特征摘要、重复行和其他统计数据。

这是predict_ticket_price_auto模型：

图 13.17 – 目标分析

要了解更多关于数据探索笔记本的信息，您可以参考此链接：docs.aws.amazon.com/sagemaker/latest/dg/autopilot-data-exploration-report.html。

1. 现在，点击打开候选 生成笔记本：

图 13.18 – 候选定义笔记本

这个笔记本包含了处理步骤、算法和超参数的信息。要了解更多关于使用候选生成笔记本的信息，请参阅docs.aws.amazon.com/sagemaker/latest/dg/autopilot-candidate-generation-notebook.html。

摘要

在本章中，您学习了在 Amazon Redshift ML 中实现模型的技术。

我们讨论了您如何创建模型的一个版本。这很重要，可以跟踪您模型的质量随时间的变化，并能够使用不同版本进行推理。

我们向您展示了如何优化您的 Redshift ML 模型以提高准确性，以及您如何使用 Amazon SageMaker Autopilot 生成的笔记本来加深对 Autopilot 执行的任务的理解。

我们希望您觉得这本书有用。我们开始写这本书的目标是帮助您在这些主要领域获得信心：

• 深入了解机器学习以及如何将其用于解决日常业务问题。

• 使用 Redshift Serverless 和 Redshift ML 实现端到端的无服务器架构，用于数据摄取、分析和机器学习。

• 创建监督和非监督模型，以及各种影响您模型的技术

• 在 Redshift 中进行大规模推理查询，以使用 Redshift ML 或直接在 Amazon SageMaker 中创建的模型解决各种商业问题

我们非常感谢您花时间阅读这本书，并欢迎您就如何使 Redshift 和 Redshift ML 变得更好提供反馈。您可以在 LinkedIn 上找到我们。