微软-Azure-自动机器学习-全-

微软 Azure 自动机器学习（全）

原文：annas-archive.org/md5/188dce12e012d6f75737380a61fa01c6

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

《使用 Microsoft Azure 的自动化机器学习》将帮助你以创纪录的时间构建高性能、准确的机器学习模型。它允许任何人轻松利用人工智能的力量，提高其业务的效率和盈利能力。通过一系列点击图形用户界面（GUI），新手和经验丰富的数据科学家都可以轻松训练和部署机器学习解决方案到生产环境中。

本书将教你如何仔细、逐步地使用 Azure AutoML 的图形用户界面（GUI）和 Azure 机器学习 Python SDK。首先，你将学习如何准备数据、训练模型并将它们注册到你的 Azure 机器学习工作区。然后，你将学习如何使用这些模型创建既包含机器学习管道的自动化批量解决方案，又包含使用Azure Kubernetes 服务（AKS）的实时评分解决方案。

当你完成《使用 Microsoft Azure 的自动化机器学习》一书时，你将能够使用 AutoML 处理自己的数据，不仅能够训练回归、分类和预测模型，还能利用它们解决各种商业问题。你将能够通过自动生成的图表和图形向商业伙伴展示你的机器学习模型是如何进行预测的，从而赢得他们的信任和尊重。

本书面向对象

数据科学家、有志成为数据科学家的人、机器学习工程师以及任何希望在业务中应用人工智能或机器学习的人会发现这本书很有用。在开始学习这本书之前，你需要具备人工智能的入门级知识以及计算机科学、统计学或信息技术方面的技术背景。拥有 Python 背景将有助于你实现本书的更高级功能，但即使数据分析师和 SQL 专家在完成本书后也能训练机器学习模型。

本书涵盖内容

第一章，介绍 AutoML，首先解释了工业界数据科学和人工智能的现状以及为什么许多公司在从数据中提取价值方面如此困难。它解释了数据科学家是如何工作的，为什么他们的流程本质上很慢，以及为什么需要加快这些流程。最后，它介绍了 AutoML 作为满足工业界投资回报要求的解决方案。

第二章，Azure 机器学习服务的入门，深入解释了 Azure 机器学习的不同组件以及它们如何集成以形成端到端的机器学习解决方案。你将了解数据存储、数据集、计算实例、计算集群、环境和实验，以及如何使用它们在 Azure 上创建机器学习解决方案。

第三章，训练您的第一个 AutoML 模型，将指导您使用公开可用的泰坦尼克号数据创建您的第一个 AutoML 模型。您将使用 Azure 机器学习工作室 GUI 将数据上传到您的工作区，创建数据集，并运行一个 AutoML 分类作业来预测泰坦尼克号幸存者。最后，您将使用 AutoML 的可解释性功能来查看哪些因素对预测生存最为关键。

第四章，构建 AutoML 回归解决方案，将帮助您使用 Python 中的 Azure 机器学习 SDK 训练 AutoML 回归模型。您将学习如何访问 Azure 机器学习中的 Jupyter 笔记本，使用计算集群在云上进行远程训练，并创建一个预测数字的 AutoML 模型。到本章结束时，您将能够为未来遇到的任何回归问题复制这项工作。

第五章，构建 AutoML 分类解决方案，将帮助您使用 Python 中的 Azure 机器学习 SDK 以两种方式训练 AutoML 分类模型。首先，您将训练一个二元分类模型来预测两个类别中的一个。然后，您将训练一个多类分类模型来预测三个类别中的一个。到本章结束时，您将成为训练所有类型分类模型的 AutoML 专家。

第六章，构建 AutoML 预测解决方案，探讨了预测，这是最常见的机器学习问题之一，也是最难掌握的。在本章中，您将学习如何使用 AutoML 编写预测解决方案，利用高级预测特定算法和功能。您将了解预测的方方面面，并能够避免人们在预测时犯的许多常见错误。

第七章，使用多模型解决方案加速器，扩展了多模型解决方案加速器（MMSA）是如何作为一种前沿的 Azure 技术，让公司能够快速轻松地训练数十万个模型。在这里，您将学习如何访问 MMSA 并将其适应您自己的问题。这是一个仅针对经验丰富的数据科学家的强大代码解决方案，但即使是新手到本章结束时也能使用它。

第八章，选择实时评分与批量评分，探讨了实时解决方案和批量解决方案是如何代表评分机器学习模型的两种方式。本章深入分析了常见的商业场景，并解释了您应该如何选择要创建哪种类型的解决方案。本章末尾有一个测验，将测试您将业务问题与正确类型解决方案匹配的能力，从而节省您的时间和金钱。

第九章，实现批量评分解决方案，强调机器学习管道是 Azure 机器学习的首选批量评分解决方案。机器学习管道是容器化的代码，一旦创建，你可以轻松地重新运行并自动安排它们。本章将指导你使用之前章节中创建的 AutoML 模型来创建强大的批量评分解决方案，这些解决方案可以在你选择的计划上运行。

第十章，创建端到端 AutoML 解决方案，强调Azure 数据工厂（ADF）是一个无需编写代码的数据编排工具，可以轻松与机器学习管道集成。在本章中，你将学习如何无缝地将数据移动到 Azure 中，以及如何将此流程与你的评分管道集成。到本章结束时，你将了解 ADF 和 AMLS 如何结合以创造最佳的数据科学体验。

第十一章，实现实时评分解决方案，教你如何在 AKS 和Azure 容器实例（ACI）上创建实时评分端点。你将学习如何通过 Azure 机器学习工作室 GUI 的单击操作以及 Jupyter 笔记本中的 Python 代码将 AutoML 模型部署到端点，完成你的 AutoML 训练。

第十二章，利用 AutoML 实现商业价值，重点关注创建端到端解决方案只是实现商业价值的第一步；你还需要赢得最终用户的信任。本章重点关注如何通过架构图、模型可解释性和以直观、易于理解的方式展示结果来赢得这种信任。你将学习如何成为并被视为你业务的可信、可靠的合作伙伴。

为了充分利用本书

你需要满足以下要求：

为了使用使用 Microsoft Azure 的自动化机器学习，你需要一个有效的互联网连接。我们建议使用 Microsoft Edge 或 Google Chrome 以获得最佳的 Azure 门户体验。此外，如果你还没有，你将需要创建一个 Azure 账户（免费）。

如果你使用的是本书的数字版，我们建议你亲自输入代码或通过 GitHub 仓库（下一节中提供链接）访问代码。这样做将帮助你避免与代码复制粘贴相关的任何潜在错误。

在你阅读本书的过程中，请随时尝试使用自己的数据使用 AutoML。解决你感兴趣的问题将极大地帮助你学习体验。在每个章节的结尾，尝试将你的数据集适应到示例代码中。

下载示例代码文件

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

我们还提供了一系列来自我们丰富图书和视频目录的代码包，可在 github.com/PacktPublishing/ 找到。查看它们吧！

下载彩色图像

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

使用的约定

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

文本中的代码：表示文本中的代码词汇、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个示例：“您这里还有一个辅助函数，get_forecasting_output。”

代码块设置如下：

from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment
from azureml.core.compute import ComputeTarget
from azureml.train.automl import AutoMLConfig
from azureml.train.automl.run import AutoMLRun
from azureml.widgets import RunDetails

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

from azureml.pipeline.core import PipelineRun
experiment = Experiment(ws, 'your-experiment_name')
pipeline_run = PipelineRun(experiment, 'your-pipeline-run-id')

粗体：表示新术语、重要词汇或屏幕上出现的词汇。例如，菜单或对话框中的文字会以这种方式显示。以下是一个示例：“在 Azure Machine Learning Studio 的资产下的实验中，点击您的实验名称，选择您的运行 ID，点击模型选项卡，选择性能最高的算法，然后点击指标选项卡。”

小贴士或重要提示

看起来像这样。

联系我们

欢迎读者反馈。

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

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

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

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

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

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

第一部分：AutoML 解释 - 为什么、是什么、怎么做

在本部分的第一部分，您将了解为什么应该使用 AutoML 以及它是如何解决行业中的常见问题的。您还将通过用户界面构建一个 AutoML 解决方案。

本节包含以下章节：

第一章, 介绍 AutoML
第二章, 开始使用 Azure 机器学习服务
第三章, 训练您的第一个 AutoML 模型

第一章：介绍 AutoML

人工智能无处不在。从推荐你最喜欢的网站上的产品到优化《财富》500 强公司的供应链，再到预测各种规模商店的需求，人工智能已经成为一股主导力量。然而，随着人工智能在职场中越来越普遍，一个令人担忧的趋势已经出现：大多数人工智能项目都失败了。

失败可能由各种技术和非技术原因引起。有时，这是因为人工智能模型表现不佳。其他时候，则是由于数据问题。机器学习算法需要可靠、准确、及时的数据，有时你的数据未能达到这些标准。当数据不是问题，且你的模型表现良好时，失败通常是因为最终用户根本不相信人工智能能指导他们的决策。

然而，对于每一个令人担忧的趋势，都有一个有希望的解决方案。微软和其他许多公司已经开发了自动化机器学习（AutoML）来提高你人工智能项目的成功率。在这本书中，你将学习如何在微软的 Azure 云平台上使用 AutoML。如果你是数据科学家，这本书将教你如何提高你的生产力。如果你不是数据科学家，这本书将使你能够构建机器学习模型并利用人工智能的力量。

在本章中，我们将首先了解人工智能和机器学习是什么，并解释为什么公司在看到他们在人工智能上的投资回报方面如此困难。然后，我们将深入探讨数据科学家的工作方式，以及为什么从项目成功角度来看，这种工作流程本质上是缓慢且容易出错的。最后，我们将通过介绍 AutoML 作为解锁机器学习项目生产力的关键来结束本章。

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

解释数据科学的投资回报率问题
分析 AI 项目失败的原因
使用 AutoML 解决投资回报率问题

解释数据科学的投资回报率问题

数据科学家自 2016 年至 2019 年一直被福布斯杂志评为美国最佳工作，然而这份最佳工作并没有为雇佣他们的公司带来最佳结果。根据 VentureBeat 的数据，87%的数据科学项目未能进入生产阶段。这意味着数据科学家所做的许多工作对他们的雇主没有任何实质性的影响。

单独来看，这并不是一个问题。如果数据科学家既便宜又充足，公司就会看到他们的投资回报。然而，事实并非如此。根据 2020 年 LinkedIn 薪酬统计，美国所有职业级别的数据科学家总收入约为 111,000 美元。他们也很容易找到工作。

美国的一家高管招聘公司 Burtch Works 报告称，截至 2018 年，数据科学家平均在其岗位上工作了 2.6 年，那年有 17.6%的数据科学家更换了工作。数据科学家既昂贵又难以留住。

同样，如果数据科学家工作速度快，即使 87%的项目未能产生影响，投资回报率（ROI）仍然有可能实现。快速失败意味着许多项目仍然进入生产阶段，部门是成功的。缓慢失败意味着部门未能交付。

不幸的是，大多数数据科学部门都缓慢失败。要理解为什么，你必须首先了解机器学习是什么，它与传统软件开发有何不同，以及所有机器学习项目共有的五个步骤。

定义机器学习、数据科学和人工智能

机器学习 是一个通过使用数据来训练统计模型进行预测的过程。它是人工智能的一个类别。人工智能 被定义为执行认知任务（如决策）的计算机程序，这些任务通常由人类完成。数据科学 是一个职业领域，它结合了计算机科学、机器学习和其他统计技术来解决商业问题。

数据科学家使用各种机器学习算法来解决商业问题。机器学习算法最好被看作是一组在数据上执行以进行预测的数学计算。你可能在日常生活中遇到的机器学习的常见应用包括预测你的信用卡何时被用于欺诈交易、确定申请贷款时应获得多少金额，以及在线购物时推荐给你的商品。所有这些大小决策都是通过机器学习机制性地确定的。

算法有很多种，但对你来说，了解它们所有并不重要。随机森林、XGBoost、LightGBM、深度学习、CART 决策树、多元线性回归、朴素贝叶斯、逻辑回归和 k 近邻都是机器学习算法的例子。这些算法之所以强大，是因为它们通过学习数据中的模式来工作，这些模式对于任何人类来说都过于复杂或微妙，无法自行检测。

对你来说重要的是了解监督学习和无监督学习之间的区别。监督学习使用历史标记数据来做出未来的预测。

想象你是一位餐厅经理，你想通过运行广告活动来预测下个月你能赚多少钱。要使用机器学习完成这项任务，你需要收集过去几年的所有销售数据，包括以前活动的结果。由于你有过去的结果，并且正在使用它们来做出预测，这是一个监督学习的例子。

无监督学习只是将相似的数据点分组在一起。当你拥有大量关于客户的信息，并希望将他们分组到不同的桶中以便更精准地对他们进行广告宣传时，这很有用。然而，Azure AutoML 严格用于监督学习任务。因此，在创建新的 AutoML 模型时，你总是需要确保数据中包含过去的结果。

机器学习与传统软件的比较

传统软件开发与机器学习开发差异巨大。程序员习惯于创建基于明确定义的规则接收输入并产生输出的软件。另一方面，数据科学家首先收集所需的输出，然后再编写程序。然后，他们使用这些输出数据以及输入数据来创建一个程序，该程序学会如何从输入预测输出。

例如，你可能想构建一个算法，预测在特定城市特定一天会发生多少交通事故。首先，你会开始收集历史数据，例如交通事故的数量（所需的输出）以及你认为在预测该数量时可能有用的任何数据（输入数据）。天气数据、星期几、交通量以及与城市事件相关的数据都可以用作输入。

收集数据后，你的下一步是创建一个统计程序，该程序在输入和输出数据之间寻找隐藏的模式；这被称为模型训练。在训练好你的模型后，你的下一步是设置一个推理程序，该程序使用新的输入数据，利用训练好的模型来预测当天将发生多少交通事故。

另一个主要区别是，在机器学习中，在尝试之前，你永远不知道你需要什么数据来创建解决方案，你也不知道你将得到什么，直到你构建了一个解决方案。由于数据科学家永远不知道他们需要什么数据来解决任何给定的问题，他们需要向业务专家寻求建议，并使用他们的直觉来识别收集正确数据的方法。

这些差异很重要，因为成功的机器学习项目与传统软件项目的成功看起来非常不同；混淆两者会导致项目失败。具有 IT 背景但缺乏数据科学背景的管理人员常常试图遵循不适合机器学习项目的方法和时间表。

实际上，在不知道你需要什么数据或哪些算法会起作用的过程中设定硬性时间表是不现实的，许多数据科学项目之所以失败，仅仅是因为它们没有得到足够的时间和资源。然而，成功有一个秘诀。

机器学习成功的五个步骤

现在我们已经了解了机器学习是什么以及它与传统软件开发的不同之处，下一步是学习典型的机器学习项目是如何构建的。你可以以许多方式划分这个过程，但大致可以分为五个部分，如下面的图所示：

图 1.1 – 任何机器学习项目的五个步骤

让我们依次看看这些步骤。

理解业务问题

第一步，理解业务问题，意味着与最终用户交谈，了解他们试图解决的问题，并将其转化为机器学习问题。

例如，在职业篮球的世界中，一个问题可能是：“我们在挑选欧洲篮球运动员方面真的很糟糕。我们希望提高为我们的球队挑选正确球员的能力。”你需要弄清楚业务上所说的“好球员”是什么意思。在这个过程中，你可能会发现，从欧洲带来的大多数球员只打了几场比赛就被送回家，这给球队造成了数百万美元的浪费。

拥有这些信息后，你需要将问题转化为机器学习可以解决的问题。明确地思考。例如，“我们将使用球员的历史比赛统计数据和人口统计信息来预测他们在 NBA 职业生涯中的寿命”将是一个好的机器学习项目。将业务问题转化为 AI 问题总是意味着使用数据来尝试预测一个数字（在 NBA 中比赛的场次）或一个类别（球员在打了几场比赛后是否会回家）。

收集和清洗数据

第二步，收集和清洗数据，包括以下步骤：

识别和获取数据源
获取所有你想要的数据
将所有数据合并在一起
删除数据中的错误
应用业务逻辑以创建一个即使是外行人也能理解的干净数据集

这比听起来要难。数据通常很脏且难以找到。

以我们的篮球案例为例，这意味着从网络上抓取公开数据以获取每位球员的比赛统计数据和人口统计信息。错误几乎是不可避免的，因此你将不得不运用逻辑来删除或修复无意义的数字。例如，没有人能长到 190 英寸，但厘米和英寸经常被混淆。

检验你是否已正确清洗数据集并使其清晰的最佳方法是将其交给一个外行人并询问简单的问题。例如：“球员 Y 有多高？球员 X 在其职业生涯中参加了多少场 NBA 比赛？”如果他们能回答，你就成功了。

为机器学习转换数据

一旦你有一个易于理解的、清洗过的数据集，下一步就是为机器学习转换数据，这被称为特征工程。特征工程是为机器学习算法改变数据的过程。一些特征对于算法运行是必要的，而其他特征则使算法更容易找到模式。常见的特征工程技术包括对分类变量进行独热编码、缩放数值、移除异常值和填充空值。

一个复杂的问题是，不同的算法需要不同类型的特征工程。与大多数算法不同，XGBoost 不需要你填写空值。决策树对异常值的影响不大，但异常值会干扰回归模型。回到我们的篮球问题，你可能需要替换空值，对数值进行缩放，使得每一列只包含从 0 到 1 的数字范围，并对分类变量进行独热编码。

重要提示

独热编码分类变量简单来说就是将一个包含许多类别的列转换成多个列，每个列要么是 1 要么是 0。例如，如果你有一个包含值 USA、Canada 或 Mexico 的列，独热编码这一列将创建三个列，每个国家一个。来自美国的产品的行将在 USA 列中有一个 1，而在 Canada 和 Mexico 列中有一个 0。

训练机器学习模型

现在你有了数据，并且数据格式正确，是时候训练一个机器学习模型了。尽管这一步得到了很多光彩和炒作，但训练机器学习模型是一个既快又慢的过程。利用今天的技术，大多数机器学习模型只需几行代码就可以训练。

相比之下，超参数调整可能需要非常长的时间。每个机器学习算法都有你可以控制的设置，称为超参数。超参数调整是多次重新训练机器学习算法，直到找到正确的参数集。

一些算法，如随机森林，从超参数调整中获益不多。其他算法，如 XGBoost 或 LightGBM，通常会有显著改进。根据你的数据量、使用的算法以及可用的计算量，超参数调整可能需要几天到几周才能完成。

注意你需要了解多少关于个别算法的知识才能成为一名成功的数据科学家？这是该领域有如此高的入门门槛的原因之一。不要感到害怕，但请记住，当我们介绍 AutoML 时，这一点很重要。

向最终用户交付结果

你现在已经训练了你的模型并调整了其参数，你可以自信地预测 NBA 球队应该签下哪些欧洲球员。也许你已经达到了 80%的准确率，也许达到了 90%，但你的预测肯定会对业务有所帮助。尽管你的结果如此，你仍然需要让最终用户接受你的模型，信任你的模型，并使用它。与传统软件不同，这可能需要巨大的努力。

首先，最终用户将想知道模型为什么给出这样的预测，如果你使用了错误的算法，这是不可能的。黑盒模型使用本质上无法知晓的算法。然后，即使你可以给出业务解释，用户可能对那个 80%的准确率数字感到不舒服。“那是什么意思？”他们会问。

可视化是缓解他们部分恐惧的关键。对于你的篮球模型，你决定简单地展示他们应该选的球员的商业图片，以及一些简单的图表，显示我们的模型准确预测了多少名球员将成为 NBA 明星，以及我们的模型未能预测多少名欧洲 NBA 明星。

整合所有内容

你现在知道了机器学习是什么，它与传统软件开发有何不同，以及任何机器学习项目固有的五个步骤。不幸的是，行业内许多人并不了解这些。大多数企业都是数据科学的新手。许多企业认为数据科学比软件开发更相似，这干扰了机器学习项目的过程。

最终用户被数据科学家的问题弄糊涂了，因为他们没有意识到数据科学家正在尝试将他们的业务问题转化为机器学习问题。IT 部门对数据科学家为什么要求访问如此多的数据感到困惑，因为他们没有意识到在尝试之前，数据科学家并不知道他们需要哪些数据。管理层对他们的数据科学家花很少的时间构建模型而花大量时间清洗和转换数据感到困惑。

因此，机器学习过程中的步骤 1和步骤 2往往比预期的要花费更长的时间。商业用户未能以有用的方式将他们的业务问题传达给数据科学家，IT 部门缓慢地授予数据科学家访问数据的权限，而数据科学家在理解他们接收到的数据时也遇到了困难。步骤 5也很复杂，因为最终用户期望模型像典型的软件程序一样完美可解释，赢得他们的信任需要时间。

由于误解会减缓其他步骤，数据科学过程的其余部分必须快速进行，以便公司能够看到投资回报。毕竟，数据转换和模型训练是数据科学工作的核心。这正是他们接受培训要做的，而且应该快速完成。正如我们将在下一节中看到的，这很少是情况。

慢慢分析为什么 AI 项目失败

数据科学家通常来自研究背景，并以系统的方法构建机器学习模型。在获得业务问题和确定人工智能解决方案的样子后，这个过程看起来是这样的：

收集数据。
清洗数据。
转换数据。
构建机器学习模型。
确定模型是否可接受。
调整超参数。
部署模型。

如果模型在步骤 5中可接受，数据科学家将继续进行步骤 6。如果模型不可接受，他们将返回到步骤 3并尝试不同的模型和转换。这个过程可以在图 1.2中看到：

图 1.2 – 构建机器学习解决方案的传统方法

虽然这个过程遵循了图 1.1中概述的五个步骤，但它既长又繁琐。还有与转换数据、构建模型、调整超参数和部署模型相关的特定缺点。现在，我们将更详细地探讨这一过程中固有的缺点，这些缺点导致数据科学项目缓慢失败而不是快速失败，从而极大地影响了投资回报率问题：

数据必须由不同的算法进行转换。数据转换可能是一个繁琐的过程。学习如何填充空值、对分类变量进行独热编码、去除异常值以及适当地缩放数据集并不容易，需要多年的经验才能掌握。这也需要大量的代码，新手程序员很容易出错，尤其是在学习一门新的编程语言时。

此外，不同的算法需要不同的数据转换。有些算法可以处理空值，而有些则不能。有些可以处理高度不平衡的数据集，那些你只拥有少量样本的类别，而其他算法则无法处理。

如果你在去除异常值时，一个算法可能表现良好，而另一个则可能完全不受影响。无论你何时选择尝试一个新的模型，都有很高的可能性你需要花时间重新设计你的数据以适应你的算法。
某些算法需要调整超参数才能表现良好。与随机森林不同，使用 XGBoost 和 LightGBM 等算法构建的模型只有在调整它们的超参数时才能表现良好，但它们可以表现得非常好。

因此，你有两个选择：坚持使用无需调整就能表现不错的模型，或者花费数天到数周的时间调整具有高潜力但无成功保证的模型。此外，你需要大量的算法特定知识，才能使用传统方法成为一名成功的数据科学家。
超参数调整需要大量的计算时间。训练单个机器学习模型可能需要几天到几周，这似乎有些夸张，但在实践中这是常见的。在大多数公司，GPU 和 CPU 是有限的资源，数据集可能相当大。某些公司有专线来获取计算能力，而数据科学家需要大量的计算能力。

在超参数调整时，通常会进行一种称为网格搜索的操作，其中在指定的数值空间中训练每个可能的参数组合。例如，假设算法X有参数A、B和C，你想要尝试将A设置为1、2和3，将B设置为0和1，将C设置为0.5、1和1.5。调整这个模型需要构建 3 x 2 x 3 = 15 个机器学习模型来找到理想的组合。

现在，15 个模型可能需要几分钟到几天的时间来训练，这取决于你使用的数据大小、你希望采用的算法以及你的计算能力。然而，15 个模型是非常少的。许多现代机器学习算法要求你在广泛的值范围内调整五到六个参数，产生数百到数千个模型以寻找最佳性能。
部署模型很困难，学校也没有教授这方面的知识。即使你正确地转换了数据并找到了具有最佳超参数集的完美模型，你仍然需要将其部署以供业务使用。当新数据到来时，它需要通过模型进行评分并交付到某个地方。监控是必要的，因为机器学习模型偶尔会出故障，必须重新训练。然而，数据科学家很少接受模型部署方面的培训。这被认为更多的是一个 IT 功能。

由于缺乏培训，许多公司使用一些临时拼凑的架构和一系列的技术来部署机器学习。数据库查询可能由第三方软件在触发器上触发。数据可能使用一种计算机语言进行转换，存储在文件共享上的文件中，然后由另一个进程以另一种语言评分模型并将其保存回文件共享。脆弱的、临时的解决方案是常态，对于大多数数据科学家来说，这些都是工作中的培训内容。
数据科学家更关注准确性而非可解释性。从根本上说，数据科学家被训练去构建尽可能准确的 AI。Kaggle 竞赛全都是关于准确性，新的算法也是根据它们与过去解决方案相比的表现来评判的。

与此相反，商界人士通常更关心预测背后的原因。忘记包含可解释性会削弱最终用户对机器学习的信任，结果，许多模型最终被闲置不用。

总的来说，构建机器学习模型需要花费大量时间，而当 87% 的人工智能项目未能进入生产阶段时，这就浪费了大量的时间。收集数据和清洗数据是本身就需要花费大量时间的过程。

为每个模型转换数据、调整超参数以及找出并实施部署方案可能需要更长的时间。在这种情况下，很容易专注于寻找尽可能好的模型，而忽略了项目最重要的部分：赢得最终用户的信任并确保您的解决方案被使用。幸运的是，有许多问题的解决方案。

利用 AutoML 解决投资回报率问题

由于人工智能项目的失败率很高，企业对机器学习工作原理的理解不足，以及每个项目所需的时间很长，微软和其他公司一直在努力开发能够实现更快开发和更高成功率的解决方案。其中之一就是 AutoML。

通过自动化数据科学家的大量工作，并利用云计算的力量，Azure 上的 AutoML 允许数据科学家更快地工作，甚至允许非专业人士构建人工智能解决方案。

具体来说，Azure 上的 AutoML 会为您转换数据、构建模型和调整超参数。部署只需点击几个按钮即可，并且可解释性内置到解决方案中。与 图 1.2 中的传统机器学习过程相比，图 1.3 中的 AutoML 流程要简单得多：

图 1.3 – 构建机器学习解决方案的 AutoML 方法

采用 AutoML 方法可以使您更快地失败，并达到需要决定是添加更多数据还是放弃项目的状态。与其浪费时间调整没有可能成功的模型，AutoML 只需一次运行就能给出明确的答案。让我们更详细地了解一下 AutoML 的优势。

Azure 上 AutoML 的优势

让我们来看看 AutoML 的一些优势：

AutoML 自动转换数据：一旦您拥有一个清洗干净、无错误的、易于理解的格式化数据集，您只需将其加载到 AutoML 中即可。您不需要填写空值、对分类值进行 one-hot 编码、缩放数据、移除异常值，或者担心数据集的平衡，除非在极端情况下。所有这些操作都通过 AutoML 的智能特征工程完成。甚至还有数据护栏，可以自动检测数据集中可能导致构建不良模型的问题。
AutoML 使用最佳算法训练模型：在你将数据加载到 AutoML 之后，它将开始使用最新的算法来训练模型。根据你的设置和计算资源的大小，AutoML 将使用 Azure 云并行训练这些模型。在运行结束时，AutoML 甚至还会构建复杂的集成模型，结合你表现最好的模型的结果。
AutoML 为你调整超参数：当你使用 Azure 上的 AutoML 时，你会注意到它经常会反复使用相同的算法来创建模型。

你可能会注意到，在运行初期，它尝试了广泛的算法，但在运行结束时，它只专注于一个或两个。这是因为它在测试不同的超参数。虽然它可能无法在任何一次运行中找到绝对最佳的超参数组合，但它很可能会提供一个性能高、调优良好的模型。
AutoML 具有超快的发展速度：使用 Azure 上的 AutoML 构建的模型只需几点击就可以部署到 REST API 端点。附带的脚本详细说明了你需要传递到端点的数据模式。一旦你创建了 REST API，你就可以将其部署到任何地方，轻松地对数据进行评分并将结果存储在你选择的数据库中。
AutoML 具有内置的可解释性：最近，微软专注于负责任的 AI。负责任 AI 的关键要素之一是能够解释你的机器学习模型是如何做出决策的。

AutoML 生成的模型附带一个仪表板，显示模型使用的不同特征的重要性。这适用于你使用 AutoML 训练的所有模型，除非你开启了使用黑盒深度学习算法的选项。甚至单个数据点也可以被解释，这极大地帮助你的模型赢得业务最终用户的信任和接受。
AutoML 使数据科学家能够更快地迭代：通过智能特征工程、并行模型训练和自动超参数调整，AutoML 让数据科学家能够更快地失败和成功。如果你无法使用 AutoML 获得良好的性能，你就知道你需要添加更多数据。

相反，如果你使用 AutoML 实现了出色的性能，你可以选择直接部署模型，或者将 AutoML 作为基准来比较你手动编写的模型。在这个时候，预计最好的数据科学家将能够手动构建在某些情况下优于 AutoML 的模型。
AutoML 使非数据科学家能够进行数据科学：传统的机器学习有很高的入门门槛。你必须精通统计学、计算机编程和数据工程才能在数据科学领域取得成功，而这些只是硬技能。

与此相反，AutoML 可以由任何了解如何处理数据的人执行。只要具备一点 SQL 和数据库知识，你就可以利用 AI 的力量，快速构建和部署能够带来商业价值的机器学习模型。
AutoML 是未来的趋势：正如人工智能从一句口号发展成为一种实践一样，机器学习解决方案的创建方式也需要从研究项目发展到成熟的机器。AutoML 是这台成熟机器的关键部分，Azure 上的 AutoML 拥有许多功能，可以帮助您更快地失败和成功。从数据转换到部署再到最终用户的接受，AutoML 使机器学习比以往任何时候都更容易、更易于访问。
AutoML 广泛可用：微软的 AutoML 不仅可在 Azure 上使用，还可以在 Power BI、ML.NET、SQL Server、Synapse 和 HDInsight 中使用。随着其进一步成熟，预计它将被整合到越来越多的 Azure 和非 Azure 微软服务中。

摘要

人工智能和机器学习可能已经吸引了全世界的想象力，但人工智能的空中楼阁般的承诺与现实中的 AI 项目之间存在很大的差距。特别是机器学习项目，往往失败且缓慢。传统的管理者将数据科学项目视为软件工程项目，而数据科学家以手动、耗时的方式工作。幸运的是，AutoML 作为一种加快项目的方法已经出现，微软也根据您的需求创建了其 AutoML 产品。

您现在已准备好进入第二章**，开始使用 Azure 机器学习服务，该章节将向您介绍微软 Azure 机器学习工作区。您将创建一个 Azure 机器学习工作区以及启动 AutoML 项目所需的所有必要组件。到本章结束时，您将牢固掌握 Azure 机器学习工作室的所有不同组件以及它们是如何相互作用的。

第二章：Azure 机器学习服务入门

既然我们知道实现人工智能投资回报的关键是快速交付机器学习（ML）项目，我们就需要学习如何使用自动化机器学习（AutoML）来实现这一目标。然而，在我们能够做到这一点之前，我们需要学习如何使用Azure 机器学习服务（AMLS）。AMLS 是微软在 Azure 云上的顶级 ML 平台。

我们将首先创建一个 Azure 账户并创建一个 AMLS 工作区。一旦你创建了工作区，你将开始创建不同类型的计算资源来远程使用机器集群运行 Python 代码和 ML 作业。接下来，你将学习如何使用 Azure 数据集和数据存储结构来处理数据。最后，我们将概述 AutoML。这将提高你创建高性能模型的能力。

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

创建你的第一个 AMLS 工作区
构建运行你的 AutoML 作业的计算资源
在 AMLS 中处理数据
了解如何在 Azure 上使用 AutoML

技术要求

为了完成本章的练习，你需要以下内容：

上网权限
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium
微软账户

创建你的第一个 AMLS 工作区

第一次导航 Microsoft Azure 可能会感到令人畏惧。有成百上千具有相似功能的服务，很容易迷路。因此，按照此指南逐步进行非常重要，首先创建一个 Azure 账户。如果你已经有了 Azure 账户，你可以跳到创建 AMLS 工作区部分。

创建 Azure 账户

让我们开始吧：

要创建 Azure 账户，请导航至azure.microsoft.com。
点击以下屏幕截图所示的绿色开始免费按钮。根据你的位置，此按钮可能位于略有不同的位置。点击此按钮后，你将需要选择与你的微软账户关联的电子邮件地址：

注意

如果你使用 Microsoft Windows，你应该有一个微软账户。如果没有，你可以通过遵循account.microsoft.com/account上的说明来创建一个微软账户。

图 2.1 – 微软 Azure 账户创建屏幕

微软将要求你填写一些关于你的国家、名字、姓氏、电子邮件地址和电话号码的信息。然后，你必须通过电话号码验证你的身份并输入你的信用卡信息。

注意，除非您升级，否则创建 Azure 账户不会产生费用。一旦您签署协议，您将获得 200 美元的免费信用额度，用于您前 30 天的 Azure 使用。30 天期限结束时，您将不会自动收费。

重要提示

如果您已经使用电子邮件地址注册了 Microsoft Azure 免费账户，您将不会收到额外的 200 美元免费信用额度。这只能获得一次，并且您只能选择按使用付费选项。在这种情况下，请使用不同的电子邮件地址创建一个新的 Microsoft 账户并再次尝试。

在有了账户之后，您现在可以在 Microsoft Azure 中创建资源。有数百种资源可供选择，可能会让人想要探索它们。保持专注。设置 AMLS 是您使用 AutoML 必须采取的第一步。

创建 AMLS 工作空间

一旦您创建了 Azure 账户，您就可以创建一个Azure 机器学习服务 (AMLS) 工作空间。AMLS 工作空间是您在 Azure 上所有机器学习工作的集中资源。它还提供了对AML 工作室的访问。这个工作室是一个图形化网页门户，允许轻松直观地访问 AMLS 工作空间的各个不同组件。让我们开始吧：

首先导航到 portal.azure.com。
点击蓝色十字中的创建资源按钮。资源只是 Azure 服务。无论是虚拟机、云数据库还是 ML 工具，每个 Azure 服务都算作一个资源。
点击蓝色十字后，在搜索框中输入Machine Learning并按Enter。您将看到一个新屏幕，右上角有一个大蓝色烧瓶。这是 AML 的符号。
点击创建。以下截图显示了流程：

图 2.2 – 创建 AMLS 资源
然后，您将看到一个屏幕，要求您选择订阅、填写资源组、创建工作空间名称、选择区域以及选择工作空间版本。如果您有多个 Azure 订阅，请选择与您想要使用的账户关联的订阅。资源组只是一个 Azure 资源的集合。通过遵循命名约定创建一个新的资源组。

重要提示

不同的 Azure 资源有不同的命名约定。资源组必须由字母数字字符、点、连字符、括号和下划线组成，而 AMLS 工作空间必须由字母数字字符、连字符和下划线组成。如果您提供了错误的名称，只需遵循出现的任何说明即可。
通过命名您的 AMLS 工作空间并选择一个区域来填写表单的其余部分。选择一个靠近您居住地的区域。例如，如果您住在芝加哥，请选择北美中部或东美，但不要选择北欧。填写所有值后，您的表单应类似于以下截图所示。

注意，除了 AMLS 工作区外，您还会自动创建其他资源。如果您需要，将自动为您创建一个容器注册表来存储容器化的代码，因此不要创建一个：

图 2.3 – 填写好的 AMLS 工作区创建表单示例
通过点击审查 + 创建，然后点击创建来完成创建您的 AMLS 工作区。

您将看到一个显示部署正在进行中的屏幕，并将创建四个不同的 Azure 资源。这包括您的 AMLS 工作区、一个用于存储数据的存储账户实例、一个用于存储密码的Azure 密钥保管库实例以及一个用于监控您的 ML 作业的应用程序洞察资源。一旦创建，不要删除这些资源。

重要提示

一旦您创建了一个 ML 管道或实时端点，将自动创建一个 Azure 容器注册表。像其他自动创建的资源一样，不要删除它。

使用代码创建 AMLS 工作区

或者，您可以使用Azure CLI通过Bash或PowerShell创建一个 AMLS 工作区。Azure 命令行界面（Azure CLI）是一个您可以使用它来创建和管理 Azure 资源的界面。Bash 是 UNIX shell 和命令语言，而 PowerShell 是微软特定的框架。您可以通过点击portal.azure.com首页顶部的计算机屏幕图标来访问 Azure CLI。当您悬停在它上面时，会出现Cloud Shell的字样。

要创建一个 AMLS 工作区，按照以下顺序在命令行中输入以下命令：

使用以下代码安装 Azure CLI ML 扩展：
```
az extension add -n azure-cli-ml
```
接下来，创建一个资源组。确保您指定了您的 Azure 位置。-n表示资源组的名称，而-l指定其位置：
```
az group create -n automl-cli-group -l eastus
```
实例化您的 AMLS 工作区。-w表示您的工作区名称，而-g指定您的资源组。确保它与您在上一步骤中创建的资源组相匹配：
```
az ml workspace create -w automl-ws -g automl-cli-group
```

您可以在docs.microsoft.com/en-us/azure/machine-learning/reference-azure-machine-learning-cli了解更多关于工作区特定命令的信息。

现在您已经创建了一个 AMLS 工作区，您就可以探索其众多对象了。您将通过 AML 工作室来完成，这是一个建立在您的 AMLS 工作区之上的图形用户界面。

导航 AML 工作室

在您创建了 AMLS 工作区后，您现在可以导航到 AML 工作室。

要么导航到ml.azure.com，要么打开您的 AMLS 工作区并点击屏幕中间的立即启动，AML 工作室是您 AMLS 需求的唯一商店。以下截图显示了工作室及其导航栏：

图 2.4 – AML 工作室主页和导航

您的 AML 工作室一开始可能会让人感到有些畏惧。由于有很多标签页需要导航以及许多不熟悉的术语，许多初次使用用户可能会感到迷茫。为了使您的旅程更加顺畅，以下是每个标签页的描述以及它们的功能：

主页将您带回到 AML 工作室主页。
笔记本允许您使用Jupyter或JupyterLab编写代码。
自动机器学习（预览版）允许您使用引导式用户界面运行 AutoML 作业。它目前处于预览模式。
设计器（预览版）允许您使用引导式用户界面转换数据和创建 ML 模型。它目前处于预览模式。
数据集是指向 Azure 存储账户中的文件或 Azure SQL 数据库中的 SQL 查询的指针。您可以使用此标签页创建新的数据集或配置文件，更新和检索现有数据集的信息。
实验是您在 Azure 上进行的 ML 训练作业的记录。实验包含您运行的结果，以及日志、图表和图形。
管道跟踪您创建的任何 ML 管道。管道用于批量评分或模型训练，通常使用 Azure Data Factory 进行调度。使用此标签页检索您的管道名称和 ID。
模型跟踪您已训练并注册到您的 AML 工作空间中的任何 ML 模型。使用此标签页来跟踪它们。
端点跟踪您为实时评分创建的任何实时端点以及您创建的任何管道端点。您还可以在管道标签页中找到管道端点。
计算允许您创建和访问用于运行 Jupyter、JupyterLab 和 R Studio 笔记本的计算实例。它还允许您创建用于运行远程训练作业的计算集群。我们将在下一节中创建这两个实例。
数据存储是指向 Azure 存储账户中的 blob 容器或 Azure SQL 数据库的指针。您可以使用此标签页创建新的数据存储并检索现有数据存储的信息。
数据标注对于标注图像数据非常有用。当您手动标注图像时，您可以训练一个机器模型，以便将来使此过程自动化。

在本章的其余部分，我们将探讨计算、数据集和数据存储标签页。随着我们继续阅读本书，我们将使用自动机器学习、实验、模型、管道和端点标签页。我们不会涵盖笔记本、设计器或数据标注标签页。要使用 GUI 或代码运行 AutoML 作业，您首先需要计算资源，所以让我们从这里开始。

构建计算以运行您的 AutoML 作业

第一次打开 AML 工作室时，导航到计算选项卡以创建计算实例和计算集群。一旦打开选项卡，你将在顶部看到四个标题：计算实例、计算集群、推理集群和附加计算。让我们更详细地看看这些：

计算实例是你可以用来在 Jupyter 或 JupyterLab 笔记本中编写和运行 Python 代码的虚拟机；你也可以使用计算实例来使用 R Studio 编写 R 代码。
计算集群是用于远程训练 ML 模型的虚拟机组。你可以在计算集群上启动作业，并在计算实例中继续编写代码。
推理集群是用于实时评分数据的虚拟机组。
附加计算指的是使用 Databricks 或 HDInsight 计算来运行大数据作业。

让我们看看它们在实际中的表现。

创建计算实例

我们将从计算实例开始：

确保顶部的选项卡以黑色突出显示。然后，点击以下截图中的添加新项按钮，即蓝色的十字：

图 2.5 – 创建计算实例

你将被要求选择虚拟机类型和虚拟机大小。选择虚拟机类型为CPU，虚拟机大小为Standard_DS3_v2。Standard_DS3_v2是大多数使用小型到中型数据集的 ML 作业推荐使用的虚拟机。

对于更大的数据集，你可能需要具有更多 RAM 的虚拟机。作为一个粗略的指导，我们建议拥有比你的 CSV 格式数据大小多 20 倍的 RAM。一旦你设置了你的设置，如图所示，点击下一步：

重要提示 – CPU 与 GPU

对于你大多数的 AutoML 和 ML 作业，CPU 将足够。然而，当你训练深度学习模型时，你想要选择更昂贵的 GPU 虚拟机。

图 2.6 – 计算实例设置
然后你将被要求给你的计算实例命名。你可以给它任何你想要的名称，或者使用automl-compute-instance，如图所示，然后点击创建：

图 2.7 – 命名你的计算实例
现在你已经创建了一个计算实例，你可以开始编码以完成剩余的任务，或者你可以继续使用 GUI。要编写 Python 代码，只需打开以下截图中的Jupyter链接：

图 2.8 – 打开 Jupyter 笔记本
你可以通过在 Jupyter 中创建 Python 笔记本来开始编码。为此，点击屏幕右上角的新建按钮。从下拉菜单中选择带有 AzureML 的最新 Python 版本，如图所示：

图 2.9 – 创建新的 Python 笔记本

现在，您已经准备好开始编码了！

创建计算集群

您的下一步是创建一个计算集群，以便您可以使用可视化界面运行 AutoML 作业。您可以通过 Jupyter 笔记本中的代码或通过 GUI 创建计算集群。

要通过 GUI 创建计算集群，请点击计算选项卡，点击计算集群，然后点击创建按钮，如图所示：

图 2.10 – 创建计算集群
在创建计算集群时，还有更多设置。首先，根据命名规范创建一个名称。计算集群只能有 16 个字符长的名称，所以请仔细思考。您的区域会自动选择，以匹配您的工作空间。

如前所述，选择虚拟机的类型为CPU，虚拟机的大小为Standard_DS3_v2。对于虚拟机优先级，选择专用而不是低优先级。在高峰使用期间，运行在低优先级虚拟机上的作业可能会被中断。然后，点击下一步，如图所示：

图 2.11 – 计算集群设置 – 第一部分
在下一页上，首先根据命名规范命名您的计算集群。计算集群只能有 16 个字符长的名称，所以请仔细思考。然后，选择节点数量。这是计算集群与计算实例之间最重要的区别。

使用计算实例，您有一个单独的节点来运行您的作业；使用集群，您可以设置节点数量的最小值和最大值，并且它们将根据您的作业自动扩展。AutoML 通过在不同的节点上并行训练不同的模型来利用计算集群。

将最小节点数设置为0以在无作业运行时最小化您的成本，并将最大节点数设置为4。最后，将节点缩放前的秒数更改为1200秒，即20分钟，以防止您工作时机器关闭。检查您的设置是否与以下截图所示一致，然后点击创建按钮：

图 2.12 – 计算集群设置 – 第二部分

使用代码创建计算集群

您还可以使用 Jupyter 笔记本中的 Python 代码创建计算集群。让我们看看：

首先，导入必要的包，以便您能够连接到您的 AMLS 工作空间并创建您的计算集群：

import azureml.core
from azureml.core.workspace import Workspace
from azureml.core.compute import ComputeTarget, AmlCompute

现在，使用以下代码连接到您的 AMLS 工作空间：
```
ws = Workspace.from_config()
```

接下来，设置您的变量，以确保它们与您在 GUI 上创建集群时使用的设置相匹配：

compute_name = 'automl-cluster'
compute_min_nodes = 0
compute_max_nodes = 4
vm_size = 'Standard_DS3_v2' 
idle_seconds = 1200

一旦存储了变量，请使用以下代码为您的计算集群创建一个配置配置：

Compute_Config = AmlCompute.provisioning_configuration(vm_size=vm_size, min_nodes=compute_min_nodes, max_nodes=compute_max_nodes, idle_seconds_before_scaledown = idle_seconds)

最后，创建计算目标：

compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)
compute_target.wait_for_completion(show_output=True)

接下来，我们将看到另一种创建计算集群和实例的方法。

使用 Azure CLI 创建计算集群和计算实例

创建计算集群和计算实例的第三种方式是通过 Azure CLI。要这样做，请通过导航到portal.azure.com并点击屏幕右上角的计算机屏幕图标来打开 Azure CLI。当您悬停在图标上时，它将显示云 Shell。一旦打开，请执行以下操作：

创建计算实例。-n表示您的计算实例名称，而-s指定您的虚拟机大小：
```
az ml computetarget create computeinstance -n clicompute -s "STANDARD_DS3_V2" -v
```
创建计算集群。-n表示您的计算集群名称，而-s指定您的虚拟机大小。您还需要设置您的最小和最大节点数：
```
az ml computetarget create amlcompute -n clicluster –min-nodes 0 –max-nodes 1 -s STANDARD_DS3_V2
```

您现在知道有三种方法可以在 AMLS 上创建计算：通过 GUI、通过 Python 代码和通过 Azure CLI。通过创建计算，您现在可以运行所有想要的 AutoML 作业。将计算视为 AutoML 的引擎。然而，像任何引擎一样，它需要燃料才能运行。如果计算是 AutoML 的引擎，数据就是它的燃料。

在 AMLS 中处理数据

现在您已经创建了计算，您需要做的就是创建一个数据集，然后您就可以准备运行您的第一个 AutoML 作业了。数据集是您存储账户上的文件或 Azure SQL 数据库上的 SQL 查询的指针。

数据集本身不是文件。您可以从本地文件、SQL 查询或存储账户中的文件创建数据集。Azure Open Datasets，由微软整理的公开可用数据，也可以注册为数据集。对于这个练习，我们将使用 Diabetes 公开数据集创建一个数据集。

使用 GUI 创建数据集

让我们开始：

点击数据集标签。
点击Sample: Diabetes、Sample: OJ Sales Simulated Data和手写数字的 MNIST 数据库对于演示 ML 很有用。您可以使用 Diabetes 进行回归、OJ Sales 进行预测，以及 MNIST 进行深度学习图像识别。
在搜索栏中输入Diabetes，点击样本：Diabetes复选框，然后点击下一步，如图 2.14 所示：

图 2.14 – 选择样本 – Diabetes 公开数据集
现在，您将被要求命名您的数据集。数据集名称必须在您的工作区中是唯一的。与许多其他 Azure 项目不同，数据集名称可以包含空格，但不能以空格开头或结尾。数据集还包含版本号，从 1 开始。

每次您更新数据集，使其指向包含更新数据的不同文件时，都会创建一个新的版本。将您的数据集命名为Diabetes Sample并点击创建，如图所示：

图 2.15 – 为您的数据集命名

恭喜！现在，您有一个可以用于 AutoML 的数据集。

使用代码创建数据集

与计算集群一样，您也可以完全通过代码创建数据集：

首先加载以下包。Diabetes使Sample: Diabetes可用，而Dataset允许您创建、注册和使用数据集：
```
from azureml.opendatasets import Diabetes
from azureml.core import Dataset
```
在导入您的包后，运行以下代码以将糖尿病数据作为表格数据集拉入。表格数据集指的是包含行和列的数据，而文件数据集用于非表格数据，如图像文件：
```
diabetes_tabular = Diabetes.get_tabular_dataset()
```

接下来，给您的数据集命名并在工作区中注册它。为此，您需要我们在创建计算集群时使用的 workspace 代码：

from azureml.core.workspace import Workspace	
ws = Workspace.from_config()
diabetes = diabetes_tabular.register(workspace=ws, name='Diabetes Sample')

一旦将数据集注册到您的 AMLS 工作区，未来调用它就非常简单。只需导航到数据集标签，选择您的数据集，然后点击消费以获取调用数据集所需的代码。点击示例用法旁边的折叠页面图标，将代码复制到您的剪贴板，如图下所示：

图 2.16 – 使用您的数据集

现在，您已经学会了如何使用 GUI 和代码创建数据集。数据集不仅对 AutoML 有用，对 AMLS 中的所有任务都很有用。访问数据集就像将自动生成的代码复制到工作室一样简单。在进入下一节之前，尝试使用 GUI 从本地文件创建自己的数据集。

您的 AutoML 已准备好运行。您在上一节中构建了引擎，现在您有了燃料；那就是您的数据。然而，在尝试 AutoML 之前，了解它是如何工作的是非常重要的。毕竟，您不希望把它开进沟里。

理解 Azure 上的 AutoML 是如何工作的

在运行您的第一个 AutoML 实验之前，了解 Azure 上的 AutoML 是如何工作的是非常重要的。毕竟，AutoML 不仅仅是机器学习，它还涉及数据转换和处理。

如以下图所示，您可以将 AutoML 的阶段大致分为五个部分：数据守卫检查、智能特征工程、迭代数据转换、迭代 ML 模型构建和模型集成。只有在这个过程的最后，AutoML 才会产生一个最佳模型：

图 2.17 – Azure AutoML 流程

让我们更详细地看看这个过程中的每一步。

使用数据守卫确保数据质量

数据守卫检查确保您的数据适合 AutoML，如果不适合，将相应地调整数据。目前对您的数据执行了六个主要检查。其中两个检查——一个用于检测缺失值，另一个用于检测高基数列——将在每个数据集中发生。其他四个检查是问题或设置相关的。

缺失特征值填充将检测您数据集中的任何空值。另一方面，高基数特征处理将识别任何具有大量唯一值的分类列。这些对于下一步都很重要；即，智能特征工程。

与前两个检查不同，验证分割处理只有在您将验证配置设置为自动时才会发生。我们将在第四章、第五章和第六章中介绍所有不同的设置。此检查自动将数据分成训练集和测试集，这样您就无需手动操作。这是 AutoML 加快数据科学流程的许多方法之一。

类别平衡检测针对试图预测一个类别的分类问题，而内存问题检测和频率检测针对试图预测未来数字的预测问题。关于这些检查的更多内容将在第五章**构建 AutoML 分类解决方案和第六章**构建 AutoML 预测解决方案中讨论，分别涵盖分类和预测。

通过智能特征工程改进数据

一旦您的数据通过了数据守卫检查，下一步就是智能特征工程。这包括填充缺失值，处理高基数分类特征，生成额外特征，以及进行分类特征的独热编码。这里还应用了更高级的特征工程技术，如 k-means 聚类、证据权重和高级文本分析。

首先，任何由所有缺失值、相同值或极高基数（ID 字段、GUID 等）组成的列将被自动删除。接下来，您的缺失数值将用列的平均值（均值）填充，而您的缺失分类值将用最常见值填充。

在缺失值填充之后，将为日期时间特征和文本特征生成额外的列。日期时间特征包括年、月、日、星期、年日、季度、年周、小时、分钟和秒。文本特征包括单个、两个和三个单词组的词频。

小贴士

有时用除了平均值或最常见值之外的措施来填充缺失值会更好。在这种情况下，在数据达到 AutoML 之前填充您的数据。

独热编码随后应用于所有分类列。简单来说，这意味着创建包含 1 和 0 的列来表示原始列中的每个唯一值。如果你的原始列是 animal，则狗在新创建的狗列中会有一个 1，在其他所有动物列中为 0。高基数分类列将创建分组列（dog-cat）。

重要提示

高级特征工程也得到应用；这些技术需要数据科学和文本分析方面的专业知识。如果你想了解更多，请查看微软的 自动机器学习中的特征化 文档，位于 docs.microsoft.com/en-us/azure/machine-learning/how-to-configure-auto-features。

使用迭代数据转换对数据进行归一化以进行机器学习

当你扩展数据时，ML 模型通常表现更好。例如，如果你有一列数值数据，其值介于 5 和 10 之间，另一列的值介于 1 和 1000 万之间，通常最好对每一列进行归一化，使其最小值为 0，最大值为 1。有许多类型的归一化，幸运的是，AutoML 会为你执行这些操作，使用迭代数据转换。

每次 AutoML 训练新模型时，它都会先使用七种方法之一对你的数据进行缩放。这七种方法如下：

StandardScaler
MinMaxScaler
最大绝对值缩放器
RobustScaler
PCA
截断奇异值分解
SparseNormalizer

通常，你必须自己编写代码并尝试每种方法来确定哪种缩放方法效果最好，但使用 AutoML，你甚至不需要考虑这一点。

使用迭代机器学习模型构建快速训练模型

Azure AutoML 的核心是迭代机器学习模型构建。AutoML 将根据你的设置并行训练模型，基于广泛算法列表。微软的 AutoML 团队只选择了性能最佳的算法模型包含在 AutoML 中，并且在添加新的模型之前，它将经过广泛的测试。这确保了模型的高性能。

当你观察 AutoML 训练模型时，你经常会注意到它反复使用相同的算法。在这种情况下，它正在尝试不同的超参数组合以达到更高的评分。超参数只是你可以设置的特定于算法的设置，例如决策树中的树深度或随机梯度下降中的损失。

谈到评分，每种类型的问题——回归、分类和预测——都有不同的度量标准可以用来评分。AutoML 也为每种问题类型使用不同的算法集。关于评分指标和算法的更多信息可以在 第 4、5 和 6 章 中找到，分别对应回归、分类和预测。

使用机器学习模型集成获得最佳结果

AutoML 将持续训练机器学习模型，直到达到设定的时长限制或模型数量限制。一旦超过这些限制中的任何一个，它将使用 投票集成 和 堆叠集成 执行 机器学习模型集成。投票集成根据你最佳模型的加权平均值评分数据，而堆叠集成基于你最佳模型的预测训练一个元模型。

在训练完你的集成模型后，AutoML 将停止运行并输出最佳模型。通常情况下，投票集成或堆叠集成将是你的表现最好的模型。然而，有时另一个模型可能会略微优于两者。

摘要

在本章中，你已经了解了在 Azure 中创建 AutoML 解决方案所需的所有先决条件。你创建了 AMLS 工作区，并在创建必要的计算资源以运行和编写你的 AutoML 作业之前访问了 AML 工作室。然后，你将数据加载到数据存储中，并将其注册为数据集，以便在 AutoML 运行中使用。

重要的是，你现在应该理解 AutoML 流程的四个步骤：数据守卫检查、智能特征工程、数据转换和迭代机器学习模型构建。本章中你所做的一切都将使你能够在创纪录的时间内创建机器学习模型。

你现在已准备好进入 第三章，训练你的第一个 AutoML 模型，你将通过 GUI 构建你的第一个 AutoML 模型。本章将涵盖从检查数据到评分模型和解释结果的一系列主题。到那一章结束时，你不仅能够使用 AutoML 训练模型，而且你还将能够以确保赢得最终用户信任的方式展示和解释你的结果。

第三章：训练你的第一个 AutoML 模型

拥有 Azure 账户、Azure 机器学习工作区、计算集群以及对 AutoML 工作原理的基本理解后，你现在可以开始训练你的第一个自动机器学习模型了。这将简单直接：AutoML 是一个平等器，它使即使是新手也能在几分钟内创建高级模型，无论你的背景如何，你将在本章结束时体会到它的力量。熟能生巧，本章是你成为 AutoML 实践者的第一步。

你将开始本章，通过从你的本地机器加载数据到你的Azure 机器学习工作室（AML Studio），仅选择用于训练所需的列。然后，你将使用引导用户界面进行 AutoML 模型的训练。训练完模型后，你将学习如何直接从 AMLS 门户解释你的结果。这包括标准指标，如准确率、假阳性率和假阴性率，以及一个令人惊叹的解释性仪表板，这将让你的业务最终用户印象深刻。最后，还有一个技巧和窍门部分，将帮助你未来的项目。

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

将数据加载到 AMLS 以进行 AutoML
创建 AutoML 解决方案
解释你的 AutoML 结果
解释你的 AutoML 模型
获得更好的 AutoML 性能

技术要求

要跟随本章内容，你需要以下条件：

上网访问
一个网络浏览器，最好是谷歌 Chrome 或微软 Edge Chromium
一个 Microsoft Azure 账户
一个 Azure 机器学习服务工作区

将数据加载到 AMLS 以进行 AutoML

正如你在第二章中注册了糖尿病公开数据集，Azure 机器学习服务入门，你现在将使用 AMLS 注册一个公开可用的泰坦尼克号数据集。

然而，与糖尿病数据集不同的是，你将直接从你的桌面将数据加载到门户。泰坦尼克号数据集包含有关谁在著名的灾难性航行中幸存和死亡的信息。你将构建一个模型，根据人口统计信息（如年龄和性别）以及票务信息（如乘客等级和票价）来预测幸存者：

首先，你需要从 GitHub 仓库下载泰坦尼克号数据。
然后，你需要通过导航到ml.azure.com来打开你的Azure 机器学习工作室。
一旦你进入工作室，点击工作室右侧资产下的数据集。
然后，点击创建数据集，并从下拉菜单中选择从本地文件，如图 3.1 所示：

图 3.1 – 从本地文件创建数据集
在加载泰坦尼克号数据之前，您必须命名您的数据集。在数据集名称文本框中写下Titanic Training Data。与许多其他 Azure 资源不同，您可以在数据集的名称中包含空格。
由于泰坦尼克号数据包含列和行，请选择包含乘客人口统计信息和票务信息的泰坦尼克号数据。我们将使用这些数据来建模谁在泰坦尼克号航程中幸存下来。

通常来说，在数据集名称中包含项目名称和使用情况是一个好主意，例如，Titanic Training Data或Titanic Scoring Data。在描述字段中，最好列出数据中包含的信息类型，以及您试图解决的问题。请参阅图 3.2以供参考。
在屏幕底部点击下一步：

图 3.2 – 命名和描述您的数据集
现在，您将把泰坦尼克号数据加载到您的默认数据存储中。您的默认数据存储指向与您的 Azure 机器学习工作区一起创建的存储帐户。通过点击相应的圆圈选择您的默认数据存储，如图图 3.3所示。
在您的本地机器上点击titanic.csv，然后点击打开。请注意，它将在文件加载到 Azure 后告诉您文件的大小。
在您的数据存储和文件选择后，您还可以确定在数据存储中保存文件的路径。在标签为/titanic/train的空字段中。这将创建一个名为titanic的文件夹结构，一个名为train的子文件夹，以及一个包含当前 UTC 格式的日期和时间的另一个文件夹。您也可以使用数据存储上的现有文件夹。请参阅图 3.3以供参考。
在屏幕底部点击下一步以继续：

图 3.3 – 将泰坦尼克号数据上传到您的数据存储
在您的数据已加载到数据存储后，现在是时候设置您的数据集，以便文件正确地进入您的 Azure 机器学习工作区。这里有以下五个选项：

a) 在文件格式中，您可以选择分隔符文件、Parquet 文件、文本文件或 JSON 文件。从下拉菜单中选择分隔符。

b) 然后，在分隔符下选择适当的选项。由于这是一个 CSV 文件，即逗号分隔值文件，请从下拉菜单中选择逗号。请注意，每次您进行更改时，AMLS 都会在屏幕底部生成您数据的预览。

c) 您很少需要更改编码，通常最好将其保留在默认设置，在这种情况下，UTF-8。

d) 另一方面，列标题，您始终需要指定。AMLS 默认为无标题，但您使用的大多数文件都会有标题。选择使用第一个文件的标题来导入适当的列标题。

e) 跳过行 是在导入文件顶部或底部有额外行时非常有用的选项。虽然泰坦尼克号数据缺少这些额外行，但通常您会发现数据在最后一行包含姓名、日期或组织信息。

重要的是要删除这些额外的行，否则在尝试构建机器学习模型时将导致错误。请参阅 图 3.4 了解您的设置应该如何看起来。
点击 下一步 以选择您数据集所需的所有列：

图 3.4 – 选择您的文件的正确设置
有一些列不适合机器学习。虽然 AutoML 会自动为您删除其中大部分，但最好还是自己删除它们。以下列出的列类型不分先后顺序：
- 每行包含唯一值的列，例如 Name、ID 和 Ticket
- 具有过多空值的列，例如 Cabin
- 不包含有用信息的列
- 您的目标列的派生列
要从数据集中删除这些列，您只需将滑块向左移动，如图 图 3.5 所示。删除 PassengerId、Name、Ticket 和 Cabin：

注意

当您从数据集中删除列时，数据存储上的文件不会被修改。因此，您可以从同一文件创建多个数据集，指向不同的列。

图 3.5 – 选择您的列
从此菜单中，您还可以指定每列的类型。共有五种类型：字符串、布尔值、整数、小数和日期。布尔值用于具有两个可能值的列，例如 0 或 1。将 Survived 改为 布尔值，并将 Age 改为整数。
点击 下一步。
您现在将看到一个确认屏幕。从该屏幕，您可以查看您分配给数据集的名称及其描述、数据存储以及基础文件所在的数据存储路径，以及文件设置。您还可以从该屏幕进行数据分析，如图 图 3.6 所示。

如果您选择分析数据，您需要选择一个计算集群。此选项将为您提供每个列的摘要统计信息，包括平均值、最小值、最大值、标准差、缺失值数量、错误数量和唯一值数量。打开或关闭分析，然后点击 下一步 以创建您的数据集：

图 3.6 – 确认您的数据集详细信息

您现在已创建了一个可以在 AMLS 中使用的数据集。使用它，您将构建一个机器学习模型，预测哪些乘客幸存，哪些乘客丧生。下一步是使用 AutoML 引导的用户界面训练机器学习模型。

创建一个 AutoML 解决方案

现在你已经将 Titanic 数据加载到你的数据存储中并将其注册为数据集，你可以通过几个指导点击来训练一个 AutoML 模型：

要开始，请从左侧菜单下的作者部分点击自动机器学习。然后，点击新页面右上角标记为蓝色十字的新建自动机器学习运行，如图图 3.7所示：

图 3.7 – 开始你的 AutoML 训练运行
一旦你进入下一屏幕，你将看到所有可用于训练的合格数据集。目前，AutoML GUI 的运行只支持表格数据集。你也可以通过点击创建数据集按钮从该视图创建一个新的数据集，如图图 3.8所示。
点击下一步：

图 3.8 – 选择你的训练数据集

在选择数据集后，下一步涉及给你的实验命名，选择一个预测列，以及选择一个用于远程训练的计算集群。记住，实验记录了与你的训练运行相关的所有信息。
要创建一个新的实验，选择Titanic-Training。不允许在实验名称中有空格；唯一允许的特殊字符是破折号或下划线。
接下来，从下拉菜单中选择你的目标列。你的目标列是你试图用机器学习模型预测的数字或类别。在这种情况下，选择Survived。
同样，选择一个 AutoML 将创建机器学习模型的计算集群。从下拉菜单中选择你创建的任何计算集群。AutoML 将在远程运行，允许你在 AMLS 工作区继续其他工作。
请使用图 3.9作为参考来确认你的设置，然后点击下一步以进入最终屏幕：

重要提示

在训练自动机器学习模型时，选择正确的大小和类型非常重要。你的计算集群上的 RAM 应该比你的数据集大约大 20 倍以确保安全。在使用深度学习算法时使用 GPU，对于其他所有操作使用 CPU。在需要切换到基于 Spark 的解决方案之前，你可以使用最多 10GB 的数据来训练 AutoML 模型。

图 3.9 – 配置你的 AutoML 运行

你只需点击几下就能创建你的 AutoML 模型。在下拉菜单中，有三个选项：分类、预测和回归。分类用于当你试图预测一个类别时，例如预测一个人是否可能违约或偿还贷款。回归用于当你试图预测一个数字而不是一个类别时，例如尝试根据房屋的大小等特征预测房价。另一方面，预测用于当你试图预测未来的一个数字时。
由于我们正在尝试预测一个人是否在泰坦尼克号灾难中幸存，请选择分类。在右侧的框旁边将出现一个绿色的勾选标记，如图 3.10 所示：

图 3.10 – 选择正确的任务类型

你可以配置两组额外的设置 - 附加配置设置 和 特征化设置。附加配置设置 允许你更改 AutoML 将用于评估算法的指标，使你能够阻止 AutoML 尝试某些算法，并允许你设置 AutoML 运行的总时间。

特征化设置 允许你取消选择列，设置列类型，并决定 AutoML 如何处理每列的空值。更高级的数据科学家能够利用这些功能以更细粒度地控制 AutoML 处理缺失值的方式以及 AutoML 如何特征化你的数据集。
导航到 查看附加配置设置。
点击 0.25，如图 3.11 所示。如果你不小心将其设置为 15，你的作业将在运行 15 小时后终止：

重要提示

目前，请坚持使用默认指标和默认验证机制，分别是 准确度 和自动。在后面的章节中，我们将更深入地探讨 Azure 上 AutoML 支持的各种指标和验证机制。

图 3.11 – 设置你的训练作业时间
点击保存和完成，然后在接下来的 15 分钟内找些事情做。

你已经启动了你的第一个 AutoML 模型，很快你将得到结果。

解释你的 AutoML 结果

你的训练运行应该大约花费了 15 分钟，并产生了一个大约 80% 准确度的模型。然而，你的结果远不止这个简单的指标。有数据护栏会通知你数据中可能存在的问题。还有针对三种问题类型的不同指标以及辅助你向业务展示结果的图表和图形：

首先，点击如图 3.12 所示的 Titanic-Training 实验：

图 3.12 – 检查你的结果

你将被带到包含关于你的模型的多种指标的屏幕，包括用于训练最佳性能模型的算法类型、其准确度得分、创建的日期和时间，以及你的 AutoML 运行执行所需的时间。利用屏幕右下角的描述区域来写下关于你运行的详细信息。
点击笔形图标并写下我的第一个 AutoML 模型。

你会注意到屏幕顶部有六个标签页：详情、数据安全栏、模型、输出 + 日志、子运行和快照。为了解释结果，只有数据安全栏和模型是重要的。
点击数据安全栏标签并阅读结果。

理解数据安全栏

数据安全栏识别并纠正你数据集中存在的问题，了解这些问题是至关重要的。根据你试图解决的是分类、回归还是预测问题，有不同的安全栏。分类问题使用以下：

验证集处理：这个安全栏会查看你的数据集大小和列中的唯一值，以确定你的机器学习模型应该如何进行训练和验证。对于这个泰坦尼克号数据集，它将选择 10 折交叉验证。交叉验证将数据分成 10 份，基于 9 份数据训练一个模型，并在剩余的部分上评分。这个过程重复 10 次，然后平均分数。
类别平衡检测：这个安全栏会查看你的目标列，以确定是否有足够的每个唯一值的样本。对于泰坦尼克号数据，这个安全栏将通过，因为有足够数量幸存者和死亡者的人数来构建一个有效的模型。
Age列，并且它们被填充了该列的平均值。Embarked列也有两个空值，并且它们被填充了--，这是该列最常见的值。
高基数特征检测：这个安全栏会检查你的分类列，看是否有任何列有太多的唯一值，在这种情况下，它们将被分箱。在泰坦尼克号数据中，这个安全栏通过了，数据保持未更改。

理解模型指标

在探索数据安全栏之后，下一步涉及解释你的模型：

点击模型旁边的数据安全栏标签。在这个标签页上，你会看到一个按准确性排序的 AutoML 生成的模型列表，得分最高的模型位于顶部。
点击显示在图 3.13中的最高得分模型的名称：

图 3.13 – 导航到你的模型

这将带您到一个类似的屏幕，顶部有一组新的标签页。指标，顶部的第四个标签页，不仅包含准确率，还包括与分类问题相关的所有附加指标和图表。您可以检查并取消选择任何您想要的。有超过 20 个复选框，但，为了这个练习的目的，我们将检查三个。
选中准确率、混淆矩阵和马修斯相关系数复选框。

准确率是一个简单且易于理解的指标，它是您的 AutoML 运行用来构建和确定最佳模型的基础。它简单地表示您的模型在做出预测时正确性的可能性。在我的案例中，它是 83.84%。与确定性系统不同，机器学习模型的得分不会完全相同，但您的最佳模型应该得分相似。

马修斯相关系数是一个更为复杂的指标，它考虑了不平衡的类别。它是真实阳性、假阳性、真实阴性和假阴性率的组合，其值介于-1 和 1 之间。

得分为 1 表示您的模型预测完美，得分为 0 表示您的模型随机猜测。得分为-1 表示您的模型每次都完全错误。我的得分是.6541，远低于我在图 3.14中看到的准确率得分。您的模型应该得分相似。这表明您的模型在识别两个类别中的一个方面可能要差得多。正如您接下来将看到的，您的混淆矩阵证实了这一点：

图 3.14 – 准确性和马修斯相关系数

混淆矩阵是您分类输出的视觉表示，专注于真实和假阳性以及阴性。虽然您的准确率很高，但您的马修斯相关系数很低，混淆矩阵是您调查这种关系的完美工具。请参见图 3.15：

图 3.15 – 混淆矩阵

这个输出表明，我的模型正确识别了 509 个在泰坦尼克号上死亡的人的案例和 238 个存活的人的案例。然而，模型错误地将 40 个遇难者误认为是幸存者，以及 104 个死者误认为是幸存者。图 3.16通过从下拉框中选择归一化显示了相对百分比：

图 3.16 – 归一化混淆矩阵

在这里，我们可以看到真实阴性率，即被正确分类为死亡的人的比率是 92.71%。假阴性率，即幸存者但被错误分类的人的比率仅为 7.29%。这些得分非常高。然而，真实阳性率，即模型正确预测谁会幸存的能力，仅为 69.59%。同样，假阳性率是 30.41%。我们有一个模型在预测灾难受害者方面比预测幸存者要好得多。

在指标标签下还有许多其他有用的指标和图表。尝试勾选几个框并研究它们的含义。你还可以从你右侧的下一个标签输出+日志直接将任何图表下载到你的电脑上。你不会在指标标签下找到的一组有用信息是用于创建你的模型的特征。这些数据可以在解释标签下找到，目前处于预览状态。

解释你的 AutoML 模型

了解你的结果很重要，但了解你的模型是如何得出这些结果的也同样重要，这对于使用机器学习来说至关重要。这正是模型可解释性发挥关键作用的地方。“可解释性”是指能够说明在构建你的 AutoML 模型时哪些特征最为重要。这在需要合法解释你的机器学习模型的行业中尤为重要，例如，如果你构建了一个用于确定谁有资格获得贷款的模型：

首先，点击“指标”旁边的“解释”标签。
点击屏幕右侧“解释 ID”下的第一个 ID。
点击“查看先前仪表板体验”旁边的滑块按钮。
点击“全局重要性”。

立即，你会看到你的列按照重要性顺序排列。性别是最重要的列，其次是舱位和年龄，如图 3.17 所示。性别的权重值为1.1，大约是舱位的两倍，得分为0.59。所有值都是相对的。从这张图表中，你可以得出结论，性别是在创建你的模型时使用的重要特征。

图 3.17 – 可解释性

现在你能够解释你的整个模型，同样重要的是能够解释个别点。
要实现这一点，请点击摘要重要性并选择任何单个数据点。

下面将出现一个图表，显示哪些特征对预测个人是否存活或死亡有负面影响或正面影响。图 3.18显示了持有头等舱票的男性的档案。请注意，他的性别对他的预测生存有负面影响，而他的舱位对预测有正面影响：

图 3.18 – 持有头等舱票的男性的可解释性

可解释性可以通过此仪表板界面和通过 Python 编程访问，我们将在后面的章节中看到。使用 Python，你可以将此信息存储在数据库中，以便安全保存和轻松检索。这样，你将能够解释所有的机器学习预测，并应对可能出现的任何法律挑战。

在构建并理解了一个 AutoML 模型之后，你现在可以构建更多的模型。为了更有效地做到这一点，你可以进行许多小的调整来提高性能。

获得更好的 AutoML 性能

恭喜！你已经构建了你的第一个模型，并且它的表现非常出色。然而，你还有很多小事情可以做来提高性能。毕竟，你将来还会构建更多的模型，为了构建最好的模型，你需要知道所有的技巧和窍门。以下是结束本章的技巧和窍门列表：

额外的特征工程通常会提供更优越的结果。特征工程仅仅意味着以使机器学习算法更容易找到模式的方式转换数据。例如，在泰坦尼克号数据中将票价和年龄分桶，可能比仅仅使用价格和年龄作为数值列提供更优越的结果。
说到分桶，你总是可以将回归问题分桶，将其转换为分类问题。例如，如果你试图预测人类的平均寿命，你可以尝试预测一个数字范围而不是一个具体的数字，比如60-65 岁，而不是一个确切的数字。当 AutoML 没有返回很好的结果时，这是一个有用的策略。与相同的给定数据集相比，分类问题比回归问题更容易解决，并且你通常可以为你的业务问题实现相似的价值。
启用深度学习通常会在 AutoML 中提供更优越的结果，但这需要显著更多的计算能力和时间。深度学习算法创建复杂的神经网络来进行预测，并且当输入特征是文本数据时，对于 AutoML 特别有用。不要使用基于 CPU 的计算集群，而应使用基于 GPU 的计算集群以获得必要的动力和性能。
在 AutoML 中进行预测需要精心构建的数据集和对预测特定设置的敏锐理解。在创建 AutoML 预测解决方案之前，仔细阅读第六章，构建 AutoML 预测解决方案。
让你的 AutoML 作业运行更长的时间通常意味着更好的结果，但只有到一定程度。尝试让它运行一定的时间，并注意算法是否返回更好的结果。
AutoML 会智能地调整其算法的参数，以尝试获得更高的分数。如果你注意到它反复尝试相同的算法，请记住这是预期行为，它正在尝试找到该算法的最佳参数组合。
很可能投票或堆叠集成将是你的最佳模型，尽管向人们解释这些模型的工作原理要困难得多。如果你有需要了解你模型背后数学原理的最终用户，你可以为你的运行黑名单集成模型。虽然你现在无法通过 AutoML GUI 来完成这项操作，但可以通过代码来实现。请参阅第四章，构建 AutoML 回归解决方案，以获取有关黑名单集成模型的更多详细信息。
在由小型虚拟机组成的计算集群上运行 AutoML 很便宜。在低内存虚拟机上使用时，请随意自由实验。

摘要

这标志着《使用微软 Azure 的自动化机器学习》第一部分的结束，你已经取得了很大的成就！你学会了如何将本地机器上的文件加载到你的数据存储中，并将其注册为数据集。你已经创建了你的第一个 AutoML 模型。你不仅能够通过图表和指标来解释你模型的预测结果，而且还能解释你的模型是如何进行预测的。最后，你学习了各种技巧和窍门，这将帮助你微调你的模型。你已经迈出了通往在 Azure 上掌握 AutoML 旅程的第一步。

你旅程的下一部分将涉及大量的 Python 编程。在第四章，构建 AutoML 回归解决方案中，你将使用AzureML Python 软件开发工具包（AzureML SDK）构建一个回归模型。这个 SDK 是一组命令，它将允许 Python 笔记本与你的 Azure 工作区进行交互。你将学习如何在 Python 中编写 AutoML 脚本，并使用这些脚本创建用于预测数字的强大解决方案。

第二部分：回归、分类和预测的 AutoML – 一份逐步指南

本第二部分专注于训练您使用 Azure AutoML 和 Azure ML Python SDK 执行分类、回归和预测机器学习（ML）任务。

本节包括以下章节：

第四章, 构建 AutoML 回归解决方案
第五章, 构建 AutoML 分类解决方案
第六章, 构建 AutoML 预测解决方案
第七章, 使用多模型解决方案加速器

第四章：构建 AutoML 回归解决方案

通过使用 AutoML 引导用户界面构建解决方案，你已经迈出了成为 Azure AutoML 专家的第一步。现在，是时候通过创建一个使用Azure 机器学习 Python 软件开发工具包（AzureML Python SDK）的解决方案来提升你的技能了。使用我们在第二章，Azure 机器学习服务入门中构建的 Diabetes 数据集，你将构建一个回归解决方案来预测一个人在过去一年中糖尿病病情的进展情况。

你将从这个章节开始，在你的计算实例中打开一个 Jupyter 笔记本，这将让你能够编写 Python 代码。首先，你将加载 Diabetes 数据。然后，你将训练一个 AutoML 模型并将你的训练模型注册到你的Azure 机器学习服务（AMLS）工作区。你将通过使用易于重用的 Python 脚本来完成这项工作。在检查你的模型结果后，你将学习如何注册你的模型，以便它可以针对各种回归特定指标进行优化，并微调你的解决方案以提高性能。

到本章结束时，你将完全掌握 Azure AutoML 的回归功能，并能够使用自己的数据训练回归模型。

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

准备 AutoML 回归数据
训练 AutoML 回归模型
注册你的训练好的回归模型
微调你的 AutoML 回归模型

技术要求

本章的先决条件如下：

上网权限
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium
一个 Microsoft Azure 账户
Azure 机器学习服务工作区
来自第二章，Azure 机器学习服务入门的titanic-compute-instance计算实例
来自第二章，Azure 机器学习服务入门的compute-cluster计算集群
来自第二章，Azure 机器学习服务入门的Diabetes Sample数据集

本章的代码在此处可用：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Chapter04/Chapter-4-AutoML-on-Azure.ipynb。

准备 AutoML 回归数据

在您可以使用 AutoML 训练任何模型之前，您必须有一个经过适当清洗的数据集。本节将指导您如何为任何 AutoML 回归解决方案准备数据。您将首先使用计算实例访问 Jupyter 笔记本，这是一个代码编辑器，让您可以用 Python 编写代码。之后，您将清洗、转换并注册您的数据作为 Azure 数据集。这将为您提供一个下一节中准备用于训练的数据集。

一些人对 Python 甚至是一般编程可能比较陌生，但不用担心。虽然编写 AutoML 解决方案可能看起来比使用GUI要困难得多，但实际上，这只是对样板代码进行微小修改的问题。

使用本书 GitHub 仓库中找到的代码，您只需稍作修改即可将其适应您自己的定制解决方案，并使用您自己的定制数据。此外，对于这个练习，您已经完成了大部分先决条件。您已经有了计算实例、计算集群和数据集，您只需几行代码就可以准备好训练 AutoML 回归解决方案。

设置您的 Jupyter 环境

要自己编写代码，您必须打开一个 Jupyter 笔记本。Jupyter 笔记本是一个可以编写、编辑和运行 Python 代码的环境。Python是一种在机器学习从业者中极其流行的通用编程语言，是 Azure Machine Learning 服务的基础。

以下步骤将指导您如何通过 Azure 计算实例访问 Jupyter 笔记本环境。然后，您将学习如何在环境中创建一个笔记本，这将允许您编写 AutoML 回归解决方案的脚本：

首先，通过导航到ml.azure.com打开 Azure Machine Learning Studio。
一旦您进入工作室，点击工作室右侧的管理下的计算。
如果您的计算实例目前处于暂停状态，请检查titanic-compute-instance旁边的圆形复选框，并点击启动按钮。
然后，点击应用程序 URI下的Jupyter，如图图 4.1所示：

图 4.1 – 访问您的 Jupyter 环境

一旦您访问了您的 Jupyter 环境，下一步就是创建一个 Jupyter 笔记本。您可以创建任意数量的 Jupyter 笔记本，您还可以使用此环境上传和下载文件，创建文件夹结构，并运行 Python 和 R 脚本。R是另一种在机器学习从业者中流行的编程语言，但本书中我们将不涉及它。
在屏幕右上角点击新建以访问下拉菜单。
从下拉菜单中选择Python 3.6 – AzureML，如图图 4.2所示：

图 4.2 – 创建 Jupyter 笔记本
点击屏幕左上角出现的新 Jupyter 笔记本；即 Untitled.ipynb。
通过点击 Diabetes_Regression_AutoML 到结果文本框中，并将其重命名为 Diabetes_Regression_AutoML，然后点击重命名，如图4.3所示：

图 4.3 – 重命名你的 Jupyter 笔记本

通过创建和重命名你的 Jupyter 笔记本，你现在可以开始用 Python 编码了。这是一个逐步的、可重复的过程，主要由模板代码组成。模板代码是指可以从项目到项目复用的代码，并且需要很少或不需要定制。因此，即使几乎没有 Python 经验，你也可以编写 Azure AutoML 脚本。

为 AutoML 准备你的数据

每个 AutoML 脚本都以完全相同的方式开始。首先，你需要加载你的 Python 库。库是包含有用函数的集合，这些函数让你能够完成复杂任务，而无需自己编写复杂的代码。然后，你必须设置你的工作区、数据存储、计算集群和数据集。一旦完成这些，如果需要，你可以操纵你的数据并将其保存到新的数据集中。如果不必要，只需在加载数据集后直接跳转到训练 AutoML 回归模型部分。

在以下步骤中，你将加载所有必要的库，从开始到结束运行整个笔记本。这些库足以运行本章的数据准备、模型训练和模型注册部分。然后，你将加载你在第二章**，Azure 机器学习服务入门中创建的 Diabetes 数据集。加载数据后，你将对数据进行一些轻微的转换，然后将其注册为新的数据集。让我们开始吧：

使用以下代码加载你将需要运行本章中所有内容的所有库：
```
from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment
from azureml.core.compute import ComputeTarget
from azureml.train.automl import AutoMLConfig
from azureml.train.automl.run import AutoMLRun
from azureml.widgets import RunDetails
```
Workspace 允许你连接到你的 Dataset，而 Datastore 允许你访问你之前创建的数据集和数据存储，而 Experiment 允许你记录你的 AutoML 的结果。

ComputeTarget 允许你使用你的计算集群来运行你的 AutoML 作业。另一方面，AutoMLConfig 允许你配置你的运行，而 AutoMLRun 是训练你的模型所必需的。最后，RunDetails 允许你实时跟踪你的作业。
使用以下代码加载 pandas，特别是这是查看数据集中数据的必要条件：
```
import pandas as pd
import numpy as np
```
使用以下代码将你的 Jupyter 笔记本连接到你的 AMLS 工作区：
```
ws = Workspace.from_config()
```
使用以下代码将你的计算集群设置为你在第二章**，Azure 机器学习服务入门中创建的集群：
```
compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)
```

使用以下代码设置你的数据存储。对于这个练习，我们将使用名为你的数据存储的 workspaceblobstore：

datastore = Datastore.get_default(ws)
my_datastore_name = 'workspaceblobstore'
my_datastore = Datastore.get(ws, my_datastore_name)

使用以下代码设置你的数据集。为此，请使用你在 第二章**，Azure 机器学习服务入门 中创建的 Diabetes Sample 数据集。你可以通过替换以下代码中显示的名称来重用此代码：
```
dataset_name = "Diabetes Sample"
dataset = Dataset.get_by_name(ws, dataset_name, 
version='latest')
```
重要提示

对于这段代码，你将始终需要使用你数据集的最新版本。如果你希望使用你数据集的早期版本，你可以将 'latest' 替换为一个数字。
使用以下代码查看你的数据的前 10 行，如图所示：
```
dataset.take(10).to_pandas_dataframe()
```
每次查看你的数据时，确保数据看起来正确是很重要的。验证列名是否与你的预期相符。确保值是正确的类型，数值或字符串，并且值本身看起来是合适的。例如，如果你在 AGE 列中看到一个大于 120 的数字，你可能在数据集中有问题。

如果你确实在你的数据中发现了任何不一致性，在用 AutoML 训练模型之前修复它们是很重要的。在应该为数值的列中留下字符串值会导致 AutoML 将这些列视为分类。

在某些情况下，这可能会导致性能下降。同样，在数据中留下错误可能会导致模型无法做出准确的预测。正如老数据科学谚语所说，“垃圾进，垃圾出。”始终检查你的数据，确保它不是垃圾。

输出应该类似于 图 4.4：

图 4.4 – 查看你的数据集
如果你希望更改你的数据中的任何内容，请使用 pandas 通过以下代码将你的数据集转换为 pandas DataFrame 来这样做：
```
dfRaw = dataset.to_pandas_dataframe()
```
你可能想要做的一件常见事情是删除列。你应该删除任何来自你试图预测的字段的列，这些列几乎全部是空值，或者在你处理新数据时将不可用。例如，如果你不知道新患者的 Sex 和 Age，你可以使用 pandas 的 drop 函数，如下所示：
```
df = dfRaw.drop(['AGE','SEX'], axis=1)
```
重新注册你修改后的数据，并给数据集一个新的名称；即，Diabetes Sample Age/Sex Dropped。使用以下代码，你可以将你的修改后的 pandas DataFrame 保存到你的数据存储中：
```
Dataset.Tabular.register_pandas_dataframe(df, 
datastore,
                            "Diabetes Sample Age/Sex 
Dropped")
```
你可能想要尝试的另一个常见转换是分箱。将 Age 列分为三个不同的组：18 岁以下的孩子，18 至 64 岁的成年人，以及 64 岁以上的老年人。以下代码说明了这一点：
```
ageBins = [0, 18, 65, 200] 
dfRaw['BinnedFares'] = pd.cut(titanic['Age'], ageBins)
```

数据科学家还可以移除异常值。Age 列：

AgeThreeSD = np.std(dfRaw.Age)*3
AgeMean = np.mean(dfRaw.Age)
print(round(AgeThreeSD + AgeMean)) # Prints Outlier 
Threshold
# Replace all values above Threshold with Threshold 
Value
dfRaw['Age'] = dfRaw['Age'].mask(dfRaw.Age > AgeMean, 
AgeMean)

最后一个常见的数据转换是从数值列创建基于截止点的分类列。肥胖被定义为 BMI 为 30 或更高。我们可以使用以下代码创建一个包含 1 或 0 值的列，Obesity_Flag，以指示个人是否肥胖：
```
dfRaw['BMI'] = np.where(dfRaw['BMI'] > 30, 1,0)
```

再次，使用以下代码将修改后的数据保存到你的数据存储中，并注册为一个名为Diabetes Sample Full Transform的数据集：

Dataset.Tabular.register_pandas_dataframe(dfRaw,
 datastore,
                            "Diabetes Sample Full 
Transform")

在这一节中，你已经取得了很大的成就。你的库已经加载，你的工作空间已经设置，你已经将所有必要的资源编码，以便轻松创建一个 AutoML 运行。此外，你已经将你的糖尿病数据保存为不同的数据集，你将在下一节中使用这些数据集来训练三个 AutoML 模型。

训练 AutoML 回归模型

与设置你的 Jupyter 环境和准备你的数据相比，训练一个 AutoML 模型涉及更少的步骤。首先，你需要给你的实验命名。记住，实验会自动记录你的 AutoML 运行信息。接下来，你需要设置你的目标列，这是你希望预测的列，以及一些其他设置。最后，你将使用 AutoML 来训练一个模型，并实时查看结果。

在本节中，你将创建一个实验，配置 AutoML 回归任务特定的各种参数和设置，并使用上一节中创建的数据库训练三个 AutoML 回归模型。让我们开始吧：

使用以下代码设置实验并给它命名。这是你的所有运行日志和指标将在 AML 工作室中存储的地方：
```
experiment_name = 'Diabetes-Sample-Regression'
exp = Experiment(workspace=ws, name=experiment_name) 
```
使用以下代码设置你的目标列。AutoML 将训练一个模型来预测这个列的值——在这个例子中，是Y列：
```
target_column = 'Y'
```
使用以下代码为你的任务创建一个变量。任务是你试图训练的 AutoML 模型类型，这个选项包括回归、预测和分类。对于预测没有时间元素的数值，输入regression：
```
task = 'regression'
```
重要提示

如果你试图预测具有时间元素的数据，请使用预测而不是回归。如果日期是你的列之一，或者你试图根据当前情况预测未来的值，请使用预测。
为你的主要指标创建一个变量。这个主要指标是评估你的模型的方式。你应该在这里使用归一化均方根误差。这个指标，被称为RSME，将预测值从每个观察的实际值中减去，然后平方，并平均所有观察的得分。得分越低，你的模型越好。回归的其他选项包括R2 分数、Spearman 相关系数和归一化平均绝对误差。

以下代码创建了一个变量并将其设置为归一化 RMSE。这个变量将在稍后传递到你的 AutoML 配置设置中：
```
primary_metric = 'normalized_root_mean_squared_error'
```
为特征化创建一个变量。你可以将特征化设置为auto或off。如果你将特征化设置为auto，你将不得不删除高基数特征，填充空值，对数据进行独热编码，并自己生成额外的特征。

除非你是经验丰富的数据科学家并且能够舒适地自己完成所有工作，否则请始终将其设置为 auto。以下代码还创建了一个新变量，你将把它传递到 AutoML 配置设置中：
```
featurization = 'auto'
```

要配置你的 AutoML，请运行以下代码。在这里，你将传递你的任务、主要指标、特征化设置、计算目标、数据集和目标列。你之前都创建过这些。

你还必须传递实验将运行多长时间，如果模型性能没有提高，是否将提前停止，交叉验证的次数，以及你的实验是否将记录模型解释。5 和 20：

config = AutoMLConfig(task=task,
                     primary_metric=primary_metric,
                     featurization=featurization,
                     compute_target=compute_target,
                     training_data=dataset,
                     label_column_name=target_column,
                     experiment_timeout_minutes=15,
                     enable_early_stopping=True,
                     n_cross_validations=5,
                     model_explainability=True)

训练你的模型并实时查看结果。以下代码使用你的配置设置训练 AutoML 模型，并将运行结果记录到之前创建的实验中。

在运行过程中，此代码将允许你实时跟踪会话的进度。在这里，你可以看到 AutoML 检查数据的有效性，迭代训练模型，并选择最佳模型：
```
AutoML_run = exp.submit(config, show_output = True)
RunDetails(AutoML_run).show()
```

如果你一切操作正确，你的 AutoML 运行将启动，你可以坐下来放松，观看它训练模型。首先，你会看到它执行 数据守卫 检查，如图 4.5 所示：

图 4.5 – 数据守卫检查

接下来，AutoML 将开始训练你的模型。你会注意到 AutoML 会训练不同组合的特征转换和算法。在相同的特征转换/算法对被复制的情况下，AutoML 会为该算法测试不同的超参数组合。在运行过程中，你将能够跟踪每个模型训练所需的时间、得分以及最佳性能模型的得分，如图 4.6 所示：

图 4.6 – AutoML 结果

注意到 AutoML 训练的模型在每次运行中并不逐渐变得更好。第一个训练的模型具有归一化 RMSE 为 0.1808。第三个训练的模型得分为 0.2027。使用归一化 RMSE，你的得分越低，表示越好。

实验结束时，最佳模型的得分为 0.1682。当你运行模型时，你应该看到类似但不是完全相同的结果，这取决于 AutoML 训练了哪些模型。虽然你可以在 PIPELINE 列下看到正在使用的模型和转换，但由于某些算法的参数数量庞大，超参数仍然隐藏。

你还可以通过以下图表获得这些结果的可视化。给定足够的时间，你会注意到 AutoML 会越来越好。这是因为它遵循自己的内部逻辑，尝试不同的特征工程/算法对，直到它无法找到更高性能的模型，此时 AutoML 将使用两种集成算法结束运行。

通常来说，要么是使用Diabetes Sample Age/Sex Dropped数据集，要么是使用Diabetes Sample Full Transform数据集。

图 4.7提供了结果的可视化：

图 4.7 – AutoML 结果可视化

除了这两个图表，你可以在你的 Jupyter 笔记本中找到它们之外，还有两个更多通过 AML 工作室可以访问的可视化。这些是预测值与真实值图和你的残差直方图。预测值与真实值显示了你的模型与理想模型相比的表现如何，而残差则可以让你了解你的误差是否呈正态分布。

你可以通过以下步骤访问这些图表：

导航到 AML 工作室的首页。
在资产下点击左侧面板中的模型。
点击Diabetes-AllData-Regression-AutoML。这是你训练的模型名称。
点击运行 ID下的蓝色链接。它应该以 AutoML 开头，后面跟着一长串字母和数字。这是你的实验记录下的 ID。
点击指标。
打开predicted_true和residuals的复选框。

预测值与真实值显示了你的预测与一个完美预测每个数据点的模型相比的表现如何。水平轴代表你的真实值，而垂直轴代表你的预测值。同样，虚线绿色线代表完美模型，而实线蓝色线代表你的实际模型。你的实际模型周围还有浅蓝色边界，显示置信区间。置信区间估计了你的模型在现实世界中的表现范围。请仔细检查图 4.8：

图 4.8 – 预测值与真实值图

另一方面，残差是一个直方图，它将你的误差值分箱，并计算每个箱中的数据点数量。误差只是你的预测值与真实值之间的偏差。例如，在图 4.9中，我们可以看到大约有 100 个数据点的误差在-38.5 到 0 之间，大约有 115 个数据点的误差在 0 到 38.5 之间。

在检查这个图表时，你应该确保它是钟形的。如果你的图表不是钟形的，这意味着你的误差中存在某种模式，你需要调查原因；通常这意味着你遗漏了一个重要的变量：

图 4.9 – 残差

虽然你已经使用 AutoML 训练了一个高性能的机器学习模型，但你的工作还没有结束。毕竟，一个机器学习模型只有在你能用它来预测新的数据点时才有用。过去就是过去，商业价值始终在于未来的情况。

在这种情况下，你试图预测患者结果，以便你可以识别并提前治疗那些疾病进展最快的患者。为此，你必须首先将你的模型注册用于将来使用。我们将在下一节中探讨这个问题。

注册您的训练回归模型

AutoML 让你可以轻松地将训练好的模型注册用于将来使用。在第九章**，实现批量评分解决方案和第十一章**，实现实时评分解决方案中，你将创建批量执行推理管道和实时评分端点，它们将使用你的模型。在注册模型时，你可以添加标签和描述以方便跟踪。

一个特别有用的功能是能够根据除你用来评分模型的指标以外的指标注册模型。因此，即使你使用归一化 RMSE 训练了一个模型，你也可以注册具有最佳 R2 分数的模型，即使这个模型是不同的。

在本节中，你将编写你模型的简单描述，为其添加标签，并给它起一个名字。然后，你将注册模型到你的 AMLS 工作区。它还包含代码，让你可以根据其他指标注册不同的模型。让我们开始吧：

首先，给你的模型起一个名字、一个描述和一些标签。tags按你的意愿，并在描述中尽量详细：

description = 'Best AutoML Regression Run using 
Diabetes Sample Data. This model requires the Age and 
Sex Columns.' 
tags = {'project' : "Diabetes", "creator" : "your 
name"} 
model_name = 'Diabetes-AllData-Regression-AutoML'

接下来，将您的模型注册到您的 AMLS 工作区，传递您的模型名称、标签和描述。使用上一节中训练的AutoML_run过程：
```
AutoML_run.register_model(model_name=model_name, 
description=description, tags=tags)
```
重要提示

如果你训练 AutoML 模型的时间已经过去，你可以通过使用此 ID 找到它的AutoML_run来检索它，如下所示：

experiment_name = 'Diabetes-Sample-Regression'

exp = Experiment(workspace=ws, name=experiment_name)

AutoML_run = AutoMLRun(experiment = exp, run_id = 'your_run_id')

尝试根据 R2 分数注册不同的模型。给它一个稍微不同的名字，添加一个额外的标签，并使用相同的描述：

description = 'Best AutoML Regression Run using \
Diabetes Sample Data. This model requires the Age and \
Sex Columns.' 
tags = {'project' : "Diabetes", "creator" : "your 
name", "metric" : "R2"} 
model_name = 'Diabetes-AllData-Regression-AutoML-R2' 
AutoML_run.register_model(model_name=model_name, 
description=description, tags=tags, metric = 
'r2_score')

这样，你的模型已经注册并准备好使用。你已经创建了一个回归模型，可以根据患者的性别、年龄、血压、BMI 和六项血液血清测量值，在 1 年内预测患者糖尿病的可能进展情况。尝试注册其他使用本章中创建的其他数据集训练的 AutoML 模型。给他们适当的标签、名称和描述，以区分它们。

强调良好的标签策略和健壮的描述的重要性是很重要的。当你在一个机器学习项目中工作时，这并不是什么大问题，因为你将记得你训练了哪些模型以及你用哪些数据集训练了它们。然而，当你转向其他项目并且随着时间的推移，你的记忆变得越来越不可靠。如果你没有好的标签，定位你的模型将变得困难。

一个合适的标记策略应包括项目名称、项目创建者、模型训练的指标、模型训练的数据集以及其他与模型相关的信息。没有必要包含版本号，因为 AutoML 会自动包含一个。如果你用相同的名称注册不同的模型，将注册一个新的模型版本，而旧版本可以通过指定其版本号来访问。

一旦你注册了几个不同的模型，尝试使用以下代码访问其中一个：

model = Model(ws,' 'Diabetes-AllData-Regression-AutoML-R2')

现在，你已经知道了如何使用 AutoML 注册和调用你训练过的模型。完成这一步后，我们可以继续前进，看看一些技巧和窍门，这些技巧和窍门将有助于你在未来训练模型时提高回归模型的性能。

微调你的 AutoML 回归模型

在本节中，你将首先回顾提高你的 AutoML 回归模型的技巧和窍门，然后回顾 AutoML 用于回归的算法。

提高 AutoML 回归模型

虽然 AutoML 会为你处理大部分复杂的数据转换和特征工程，但你可以遵循一些技巧来提高模型的准确性。其中一些技巧适用于所有三个 AutoML 任务——回归、分类和预测——而其他则是针对回归的。遵循这些技巧将产生性能更好的模型，更重要的是，将加深你对机器学习技术的理解。以下是一些技巧和窍门的列表，供快速参考：

在将数据传递给 AutoML 之前，先填写空值。或者，删除包含空值的任何行。仅仅因为 AutoML 会自动填充你的空值，并不意味着它会做得很好。

在某些情况下，用列的平均值填充空值是合适的。例如，如果你缺少一个物品的价格，平均价格很可能近似于缺失的值。对于噪声较大的列，深入思考你应该如何填充缺失值，或者是否应该包含这些数据点。以下是一些 Python 代码，可以为你填充空值：
```
mean_age = dfRaw.AGE.mean()
dfRaw.AGE = dfRaw.AGE.fillna(value=meanAge)
```
熟悉所有不同的 AutoML 配置选项。你可以在以下链接中找到它们：docs.microsoft.com/en-us/python/api/azureml-train-automl-client/azureml.train.automl.automlconfig.automlconfig?view=azure-ml-py。
使用y_min和y_max来处理Target列中的任何异常值。如果你有异常值，例如距离Target列平均值3个或更多标准差的价值，将y_min和y_max分别设置为平均值以下和以上的3个标准差，可以产生性能更好的模型。这仅适用于回归模型。

以下代码计算Target列的均值和标准差，并使用它们来设置y_min和y_max：
```
TargetSD = np.std(dfRaw.Y)*3
TargetMean = np.mean(dfRaw.Y)
y_min = TargetMean – TargetSD
y_max = TargetMean + TargetSD
```
研究四种不同的主要指标，以了解哪些指标最适合你的问题。对于大多数回归问题，归一化均方根误差（Normalized RMSE）就足够了，但关于使用其他指标优缺点的研究论文也很多。
使用docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml来了解一个好的回归模型是什么样的。一个好的模型将具有无偏残差，这意味着你的模型预测过高和过低的程度相同。一个好的模型还将更接近于预测值与真实值图中图 4.8所示的理想线。
在 AML studio 中，转到资产下的实验，点击你的实验名称，选择你的运行 ID，点击模型选项卡，选择性能最高的算法，然后点击指标选项卡。这将为你提供评估你的算法所需的所有不同指标和图表。
你可以使用weight_column_name配置选项为你的数据集分配一个权重列。如果某些观测值比其他观测值更重要，给这些观测值分配更高的权重。

例如，你可以给一个重要的观测值分配权重 2，而给普通观测值分配权重 1，从而将重要观测值的权重加倍。例如，如果你正在构建一个预测工厂电力使用的算法，你可能希望更重视峰值使用时间。
启用更长的实验运行时间以获得性能更高的模型。有时，这有助于 AutoML 为其训练的模型找到更好的超参数。有时，增加运行时间帮助不大，但总是值得一试。
如果 AutoML 没有提供令人满意的模型，尝试添加更多数据。你可以添加更多历史数据（更多行）或附加信息（更多列）。但是，请注意不要向一个非常小的数据集添加太多列，因为这可能导致过拟合。

过拟合是指你产生了一个非常好的模型，但它不能推广到新的数据点。如果你遇到这种情况，尝试添加更多历史数据或从你的数据集中删除列。
最后，如果在应用了所有这些技巧和窍门之后，你的模型仍然不尽人意，尝试将你的回归问题转换为分类问题。一般来说，分类问题比回归问题更容易解决。实现这一点的方法是对目标列进行分箱。

而不是试图预测一个特定的数字，你的算法将尝试预测一系列数字。为了使这种方法有效，你必须富有创造力。例如，使用Diabetes Sample数据集，尝试使用以下代码对Target列进行分箱：
```
ySD = np.std(dfRaw.Y)
yMean = np.mean(dfRaw.Y)
yMin = np.min(dfRaw.Y)
yMax = np.max(dfRaw.Y)
low = yMean - ySD
high = yMean + ySD
yBins = [yMin, low, yMean, high, yMax] 
dfRaw['BinnedY'] = pd.cut(dfRaw['Y'], yBins)
```

每当你使用将回归问题转化为分类问题的技巧时，请记住，结果的目标列必须是具有意义的。在下面的屏幕截图中，我们可以看到 Target 列的值，它表示疾病在患者身上的进展程度。

如果四个不同的分箱之间存在实质性、有意义的差异，那么这是一种有效的方法来处理问题。然而，如果每个分箱中的患者在医疗结果方面没有差异，那么你应该对数据进行分箱，以确保患者被正确地归为一组。

在 图 4.10 中，我们可以看到 Target 列的值，它表示疾病在患者身上的进展程度：

图 4.10 – 对糖尿病数据进行分箱的结果

你现在已经熟悉了数据科学家用来实现高性能模型和解决商业问题的许多小技巧。这个列表远非详尽无遗，随着你使用 AutoML 构建更多模型，你将遇到更多技巧。每次当你发现一些提高模型性能的有趣方法时，重要的是将它记录下来并将代码存储在代码库中。

每当你遇到一个看似无法解决的问题时，重新阅读本节中的所有提示，然后搜索你的代码库。大多数时候，有了正确的数据和适当的转换，AutoML 将能够生成与大多数数据科学家相当解决方案。有时，这只是一个微调设置的问题。有时，你唯一能做的就是尝试将你的回归问题转化为分类问题，然后再次尝试。

最后一件能帮助你更有效地使用 AutoML 的事情是理解该技术背后的算法。

理解 AutoML 回归算法

AutoML 使用了众多最先进的机器学习算法。虽然你不需要理解它们来使用 AutoML，但更多地了解它们将有助于你作为数据科学家的成长。某些算法在某些情况下表现更好。此外，你可以将这些算法大致分为五组。

标准回归算法是指那些为你的解释变量分配系数以预测目标列的算法。AutoML 使用了其中的两种技术：弹性网络和LARS（最小角度回归）lasso。

弹性网使用 L1 和 L2 正则化技术训练回归模型。L1，也称为lasso，将不重要变量的系数减少到 0，而L2，称为ridge，减少不重要变量系数的值。弹性网结合这两种技术来创建更简单、更容易解释的模型，同时不会像 lasso 回归那样丢弃许多变量。LARS lasso 是一种针对具有许多列的数据的技术，它迭代地使用最重要的列，但在噪声数据上表现不佳。

树算法根据一系列 if-then 决策规则来分割数据，结果是一个类似于分支树的映射。随着你向下深入树，最终你会到达一个点，算法根据它创建的一系列规则预测一个值。AutoML 使用这三种技术：

决策树是一种简单且易于解释的算法，但容易过拟合，在训练数据上表现良好，但牺牲了推广到新数据的能力。
随机森林通过创建决策树的集合并平均它们来工作。每个树都是从训练集的随机样本中创建的，并且列是随机选择的来创建决策规则。
极度随机树更进一步，通过随机化选择的分割值来增加随机性。这种随机性在推广到新数据时减少了模型的方差，从而创建了更好的模型。

梯度提升算法通过结合许多表现不佳的决策树模型，称为弱学习器，来工作。这些算法首先创建一个单一的弱学习器，寻找它表现不佳的数据点，并在该数据子集上创建另一个弱学习器。这个过程会重复进行，直到达到某个阈值。AutoML 使用这三种算法中的三种：XGBoost、LightGBM和梯度提升。这三种算法的工作方式相似，并且基于它们的高性能而被选中，但必须仔细调整以避免过拟合。

最近邻算法通过查看每一行数据并计算相似数据点的平均值，称为最近邻，来工作。K-最近邻是 AutoML 使用的唯一一种最近邻算法。K 指的是算法在做出预测时检查的最近邻数量。当你的数据列数较少时，KNN 表现良好，因为它在使用许多列来预测目标列时容易过拟合。

优化算法是那些通过迭代最小化目标函数来尝试收敛到最佳预测的算法。AutoML 使用这三种：随机梯度下降（SGD）、在线梯度下降回归器和快速线性回归器。这些算法中的每一个都是通过为每一列找到目标函数的斜率，并沿着斜率向下工作，直到通过调整权重尽可能接近 0。

这是一个非常缓慢的过程，SGD 通过随机选择斜坡上的数据点来尽可能快地达到最小值；在线梯度下降回归器的工作方式类似，但具有不同的加权选项。快速线性回归器使用一种称为随机双坐标上升（SDCA）的新最优化技术，它优化的是双损失函数而不是其他算法的单个损失函数。

图 4.11 提供了 12 种算法的总结。

图 4.11 – AutoML 回归算法

除了前面提到的 12 种算法之外，AutoML 在每个 AutoML 训练运行的末尾还会执行模型集成。模型集成是指将多个机器学习模型的预测结果结合起来进行预测。AutoML 使用两种集成技术：投票和堆叠。

投票集成对回归模型进行加权平均，并使用这个平均值进行预测。堆叠集成则相反，使用其他模型的输出训练一个弹性网络模型。AutoML 在每个训练运行中训练一个投票集成和一个堆叠集成。通常，这两个集成模型中的一个是你的最高性能模型。

更多关于这些模型的信息，请参阅位于docs.microsoft.com/en-us/azure/machine-learning/how-to-configure-auto-train#configure-your-experiment-settings的 AutoML 文档。

摘要

通过本章的学习，你已经成功使用 AzureML Python SDK 构建了一个回归模型。无论你是 Python 新手还是专家，你都加载了数据，使用 pandas 进行了广泛的转换，并使用 AutoML 构建了一个有用的机器学习模型。然后，你将模型注册到 AMLS 工作区。你将在未来的章节中使用相同的模型，通过 REST API 创建推理管道和实时评分端点。

通过完成本章的所有练习，你已经掌握了 Azure AutoML 回归解决方案的水平。你现在可以使用任何有用的数据集来预测一个数字，并使用它创建一个高性能的机器学习模型。此外，你可以用 Python 编写所有这些代码，如果模型表现不佳，你知道许多小方法来提高性能，或者，在最坏的情况下，将你的回归问题转换为分类问题。

在第五章《构建 AutoML 分类解决方案》中，你将学习如何使用 AutoML 解决这些分类问题，然后构建一个预测类别而不是数字的机器学习模型。

第五章：构建 AutoML 分类解决方案

在使用 Python 在 第四章**，构建 AutoML 回归解决方案 中构建您的 AutoML 回归解决方案之后，您应该对自己的编码能力感到自信。在本章中，您将构建一个分类解决方案。与回归不同，分类用于预测感兴趣对象的类别。例如，如果您试图预测在接下来的五年内谁有可能成为房主，那么分类是正确的机器学习方法。

二元分类是指您试图预测两个类别，例如房主或非房主，而多类分类涉及尝试预测三个或更多类别，例如房主、租房者或与家人同住。您可以使用 Azure AutoML 利用这两种技术，本章将教会您如何使用不同的数据集训练这两种类型的模型。

在本章中，您将首先直接导航到 Jupyter 环境，就像您在 第四章**，构建 AutoML 回归解决方案 中做的那样。然后，您将加载与您在 第三章**，训练您的第一个 AutoML 模型 中构建模型相同的泰坦尼克号数据。重新训练相同的模型会令人感到无聊，因此您将通过添加一些派生列来丰富数据集。

一旦您做到了这一点，您将训练、检查并注册您的二元分类模型。然后，您将使用流行的、公开可用的 Iris 数据集训练一个多类分类模型，该模型将根据其尺寸预测单个植物的花的类型。您将在本章结束时学习一些关于如何微调分类模型的小技巧和窍门。请注意，即使是经验丰富的数据科学家也常常未能修改他们的分类模型以符合手头的业务问题。

到本章结束时，您将能够轻松地独立构建所有类型的分类模型，无论您之前的机器学习经验如何。

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

准备 AutoML 分类数据
训练 AutoML 分类模型
注册您的训练好的分类模型
训练 AutoML 多类模型
微调您的 AutoML 分类模型

技术要求

对于本章，您将通过 Jupyter 笔记本中的 Python 代码在 Azure 机器学习 (AML) 工作室 中构建模型。此外，您将使用您在之前章节中应该已经创建的数据集和 Azure 资源。因此，完整的要求列表如下：

上网访问
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium
一个 Microsoft Azure 账户
一个 Azure 机器学习 工作区
在第二章**，Azure 机器学习入门中创建的titanic-compute-instance计算实例
在第二章**，Azure 机器学习入门中创建的compute-cluster计算集群
来自第三章**，训练你的第一个 AutoML 模型的Titanic Training Data数据集
理解如何从 Azure 计算实例导航到 Jupyter 环境，如第四章**，构建 AutoML 回归解决方案中所示

准备 AutoML 分类数据

分类，或根据其属性预测某物的类别，是机器学习的关键技术之一。就像回归一样，在用 AutoML 训练之前，你首先需要准备你的数据。在本节中，你将首先导航到你的 Jupyter 笔记本，加载你的数据，并将其转换为 AutoML 使用。

正如你通过 Jupyter 笔记本加载Diabetes Sample数据集进行回归一样，你将同样地加载Titanic Training Data数据集。然而，这一次，在训练你的 AutoML 模型之前，你将进行更广泛的数据转换。这是为了巩固你的学习；分类数据集不一定需要比它们的回归对应物更多的转换。与上一章相同，你将首先从你的计算实例打开一个 Jupyter 笔记本。

导航到你的 Jupyter 环境

与第四章**，构建 AutoML 回归解决方案类似，你将首先创建一个新的 Jupyter 笔记本来创建你的分类模型，如下所示：

首先，通过导航到ml.azure.com打开 AML 工作室。
一旦你进入工作室，在管理下点击右侧的计算。
如果你的计算实例当前处于暂停状态，请检查titanic-compute-instance旁边的圆形复选框，并点击启动按钮。
然后，点击之前创建的Diabetes_Regression_AutoML笔记本。每次你创建一个 Jupyter 笔记本，它都会在你的 AMLS 工作区中持久保存，即使你或其他用户从不同的计算实例访问 Jupyter 也是如此。在这个空间里，你可以随意创建尽可能多的笔记本，并仔细命名它们，这样你就可以轻松跟踪不同的项目。
在屏幕右上角点击新建以访问下拉菜单。
从下拉菜单中选择Python 3.6 – AzureML。
点击屏幕左上角出现的新的 Jupyter 笔记本，Untitled.ipynb。
通过点击结果文本框中的Titanic_Classification_AutoML并将Untitled.ipynb重命名为Titanic Classification_AutoML，然后点击重命名，如以下截图所示：

图 5.2 – 重命名你的 Jupyter 笔记本

你的笔记本创建完成后，你现在可以加载你的 Titanic 数据。

加载数据并进行转换

所有 AutoML 解决方案都使用大致相同的模板代码。如果你完成了第四章**，构建 AutoML 回归解决方案，请逐行复制你的代码单元格。完成之后，只需按步骤操作，并在必要时修改你的代码。如果你直接跳到这一章，你将不得不从头开始编写代码。

就像之前一样，你将加载 Python 库并设置你的工作区、数据存储、计算集群和数据集。然后按照以下方式转换和注册你的增强数据：

加载运行所有代码所需的全部库。请参阅第四章**，构建 AutoML 回归解决方案，以了解所有这些包的详细解释：

from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment
from azureml.core.compute import ComputeTarget
from azureml.train.automl import AutoMLConfig
from azureml.train.automl.run import AutoMLRun
from azureml.widgets import RunDetails

使用pandas和numpy加载数据。这些是流行的 Python 包，可以帮助你转换数据。特别是pandas对于查看数据集中的数据是必要的：
```
import pandas as pd
import numpy as np
```
将你的 Jupyter 笔记本连接到你的 AutoML 工作区：
```
ws = Workspace.from_config()
```

设置你的计算集群：

compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)

设置你的datastore。对于这个练习，我们将使用随 AutoML 工作区提供的默认数据存储。如果你想使用不同的数据存储，你可以替换名称：
```
datastore = Datastore.get_default(ws)
my_datastore_name = 'workspaceblobstore'
my_datastore = Datastore.get(ws, my_datastore_name)
```
设置你的dataset：
```
dataset_name = "Titanic Training Data"
dataset = Dataset.get_by_name(ws, dataset_name, version='latest')
```
注意

第 6 步是第一次你应该修改代码的地方。每次你在 Azure 中创建一个新的分类或回归 AutoML 解决方案时，都应使用此模板。
以下代码用于查看数据的前 10 行。请确保它看起来是正确的：
```
dataset.take(10).to_pandas_dataframe()
```
前十行应该如下所示：

图 5.3 – 查看你的 Titanic 数据集
将你的数据集转换为Age列。乘客的年龄很可能与其他列（如Sex）有关。我们不是用整个Age列的平均值替换这些空值，而是用按性别划分的平均年龄来替换。
计算你的Titanic数据集中男性和女性的平均年龄：
```
dfRaw = dataset.to_pandas_dataframe()
round(dfRaw.groupby(['Sex'])['Age'].mean())
```
这段代码将显示女性的平均年龄为 28 岁，男性的平均年龄为 31 岁。你将在下一个单元格中使用这些数字。
使用以下条件 Python 代码用每个性别适当的数字替换Age列中的空值：
```
dfRaw['Age'] = dfRaw.apply(
   lambda row: 31 if np.isnan(row['Age'])\
    and row['Sex']=='male'\
    else (28 if np.isnan(row['Age'])\
          and row['Sex']=='female'\
    else row['Age']),axis=1)
```
另一个常见的转换是将数值数据分箱。分箱数值数据意味着从一个数值列创建多个分类列，例如，将年龄列分割成年龄范围。当你怀疑数字的范围比绝对数值更重要时，你应该对数值数据进行分箱。

例如，如果你怀疑一个人的年龄（年轻或年老）是否对他们在泰坦尼克号上是否幸存有影响，但不是他们的确切年龄，你应该将数据分箱到不同的组中。AutoML 不会自动为你分箱数据，但某些算法，如决策树，不需要分箱就能达到类似的效果。

将Age列分箱到四个不同的年龄组：15 岁以下，15-35 岁，35-60 岁，以及 60 岁以上：

dfRaw['BinUnder15'] = np.where(dfRaw.Age < 15,1,0)
dfRaw['Bin15to34'] = np.where((dfRaw.Age>14)\
                            & (dfRaw.Age < 35),1,0)
dfRaw['Bin35to60'] = np.where((dfRaw.Age>34)\
                            & (dfRaw.Age < 61),1,0)
dfRaw['BinOver60'] = np.where(dfRaw.Age > 60,1,0)

如果你喜欢，可以尝试不同的年龄组合。

现在你已经将Age列分箱了，可以将其删除。这将是你最终的 DataFrame：
```
df = dfRaw.drop(['Age'],axis=1)
```
重新注册你的修改后的数据，并给数据集一个新的名字，Titanic Transformed。这将把你的转换后的 pandas DataFrame 保存到你的数据存储中，在磁盘上创建一个新文件：
```
Dataset.Tabular.register_pandas_dataframe(df, datastore,
                            "Titanic Transformed")
```
你可能会收到一个警告，即register_pandas_dataframe是一个实验性方法，因为它是 AML SDK 的新特性。你可以安全地忽略这个警告。

如果你刚开始接触 Python，一些代码可能会让你感到困惑，这是正常的。你会发现学习pandas和numpy库非常有价值，因为它们是两个最受欢迎的数据转换包。每次你学习一个新的pandas或numpy函数时，将示例保存到你的个人代码库中以便以后使用。即使你永远不会成为 Python 专家，你仍然可以使用 Azure AutoML 交付一个优秀的模型。然而，Python 专家仍然可以通过仔细、细致和精明的数据转换来交付最佳模型。

你现在可以使用 Titanic 数据集训练另一个模型了。在智能填充空值和分箱Age列之间，你可能期望产生一个比你在第三章**，训练你的第一个 AutoML 模型中构建的模型更优越。让我们看看这是否成立。

训练一个 AutoML 分类模型

训练一个 AutoML 分类模型与训练一个 AutoML 回归模型非常相似，但有一些关键的区别。在第四章**，构建 AutoML 回归解决方案中，你首先为你的实验设置了一个名字。之后，你设置了目标列，随后设置了 AutoML 配置。最后，你使用 AutoML 训练了一个模型，执行了数据守卫检查，并产生了结果。

本节中的所有步骤几乎都是相同的。然而，请特别注意数据守卫检查和结果，因为在训练分类模型时它们有显著的不同：

设置你的experiment并给它起一个名字：

experiment_name = 'Titanic-Transformed-Classification'
exp = Experiment(workspace=ws, name=experiment_name)

将你的dataset设置为你的转换后的Titanic数据：

dataset_name = "Titanic Transformed"
dataset = Dataset.get_by_name(ws, dataset_name, version='latest')

设置你的目标列，Survived。大小写很重要：
```
target_column = 'Survived'
```
为你的task创建一个变量：现在，task是你试图训练的 AutoML 模型类型。对于预测类别，输入classification：
```
task = 'classification'
```
重要提示

你总是可以将回归问题转换为分类问题，这通常是一个更容易解决的机器学习问题。例如，对于糖尿病问题，你可以基于Y列创建一个新列。设置一个数值阈值，并将超过阈值的任何患者分配为1，低于阈值的任何患者分配为0。然后，尝试使用 AutoML 训练一个分类模型。
为你的主要指标创建一个变量：主要指标是评估你的模型的方式。使用准确率。此指标将你的模型准确预测类（生还或未生还）的案例数量除以总案例数量。分数越高，你的模型越好。分类的其他选项包括加权 AUC、加权平均精确率分数、归一化宏召回率和加权精确率分数：
```
primary_metric = 'accuracy'
```
为特征化创建一个变量并将其设置为auto：
```
featurization = 'auto'
```
你可以将特征化设置为auto或off。如果你将特征化设置为off，你将不得不删除高基数特征，填充空值，对数据进行独热编码，并自己生成额外的特征。

使用分类时，你还需要平衡你的类别，这意味着你应该重新采样你的数据，以便在泰坦尼克号上生还和死亡乘客的数量接近相等。除非你是经验丰富的数据科学家并且能够自己舒适地完成所有工作，否则始终将其设置为auto：
设置类别数量：
```
num_classes = df[target_column].nunique()  
```
这是在训练分类模型时的主要区别。通过以下代码以编程方式执行此操作，你将永远不会像手动输入数字时那样犯错误。

重要提示

AutoML 可以处理大量类别，但如果你有过度不平衡的类别，可能会遇到麻烦。当你最大的案例数量是最小案例数量的 20 倍时，你可能想要重新采样你的数据或对目标列进行分箱以减少差异。

配置你的 AutoML 运行：在这里，你将传递你的任务、主要指标、特征化设置、计算目标、数据集、目标列和类别数量。所有这些你之前都创建过。你还将传递实验将运行多长时间，如果模型性能没有提高，它是否会提前停止，交叉验证的数量，以及你的实验是否会记录模型解释。

此外，你将传递是否想要使用5和20分割：

config = AutoMLConfig(task=task,
                     primary_metric=primary_metric,
                     num_classes=num_classes,
                     featurization=featurization,
                     compute_target=compute_target,
                     training_data=dataset,
                     label_column_name=target_column,
                     experiment_timeout_minutes=15,
                     enable_early_stopping=True,
                     n_cross_validations=5,
                     model_explainability=True,
                     enable_stack_ensemble=True,
                     enable_voting_ensemble=True)

训练你的模型并实时查看结果：

AutoML_run = exp.submit(config, show_output = True)
RunDetails(remote_run).show()

大多数代码应该感觉熟悉。启动你的 AutoML 运行，为自己泡杯咖啡，回来，观看你的模型运行。然后你会看到如图 5.4 所示的数据守卫检查。注意它如何为分类而改变。

首先，它将检查你的目标列以确保类别平衡。然后，它将填充缺失值。在这里，Embarked列中有两个缺失值。由于它是一个分类列，它将被填充为最常见的值。最后，就像回归一样，它寻找具有高基数或给定数据集中有太多唯一值的分类列：

图 5.4 – 数据边界检查用于分类

就像之前一样，完成数据边界检查后，AutoML 将开始使用不同组合的特征转换、算法和超参数来训练模型。其中一些算法是用于分类的独特算法，例如朴素贝叶斯、线性 SVC 和逻辑回归，而其他如随机森林、LightGBM和XGBoost则与回归共享。你的输出应该类似于图 5.5：

图 5.5 – 用于分类的 AutoML 结果

这些结果有两个引人注目之处：第一个训练的模型是最好的模型，而你训练的算法在第三章**，训练你的第一个 AutoML 模型中略有改进。当模型对于机器学习找到模式相对简单时，你的第一个模型可能是最好的模型。我们尝试通过自己填充空值并对Age列进行分箱来超越 AutoML 的尝试失败了。

尽管我们没有成功生成模型，但展示 AutoML 的内在力量是一个很好的练习。通常，保持数据不变会产生一个优秀的模型。有时，从现有特征中创建新特征会产生更优秀的模型。尝试实验，看看你是否可以用Titanic数据集获得更高的性能结果。参见图 5.6以查看可视化结果，并注意你可以在左上角的下拉菜单中选择其他指标：

图 5.6 – 用于分类的 AutoML 结果可视化

一旦你彻底实验了Titanic数据并达到了最高的准确率，你就可以进入下一节以注册你的模型。注册的模型对于以后通过机器学习管道或实时端点评分新数据是必要的。

注册你的训练分类模型

注册分类模型的代码与您在第四章**，构建一个 AutoML 回归解决方案中用于注册回归模型的代码相同。始终注册新模型，因为您将使用它们来对新数据进行评分，具体取决于您的用例，使用实时评分端点或批量执行推理管道。这将在第九章**，实现批量评分解决方案和第十一章**，实现实时评分解决方案中解释。同样，在注册模型时，始终添加标签和描述以便于跟踪：

首先，为您的模型命名、添加描述和标签：

description = 'Best AutoML Classification Run using Transformed Titanic Data.' 
tags = {'project' : "Titanic", "creator" : "your name"} 
model_name = 'Titanic-Transformed-Classification-AutoML'

标签让您能够轻松搜索模型，因此在实现它们时请仔细思考。

接下来，将您的模型注册到您的 AMLS 工作区，传入您的模型名称、标签和描述。使用上一节中训练的AutoML_run实例：
```
AutoML_run.register_model(model_name=model_name, \
description=description, tags=tags)
```
尝试使用以下方法基于AutoML_run注册不同的模型：

ID.experiment_name = 'Titanic-Transformed-Classification-AutoML'

exp = Experiment(workspace=ws, name=experiment_name)

AutoML_run = AutoMLRun(experiment = exp, run_id = 'your_run_id')

您已注册了您的模型，并且它已准备好使用。您创建了一个分类模型，可以用来预测在不幸的泰坦尼克号航程中谁幸存谁未幸存。它略逊于您在第三章**，训练您的第一个 AutoML 模型中构建的分类模型，但在此过程中，您学到了很多。带着您的教训，我们可以继续学习在将来训练更多模型时可以改进分类模型的小技巧和窍门。

训练一个 AutoML 多类模型

多类分类涉及预测三个或更多类别，而不是标准的二分类。使用定制机器学习，训练多类模型通常是一个混乱、复杂的过程，您必须仔细考虑您试图预测的类别数量，这些类别相对于彼此的不平衡程度，是否应该将类别组合在一起，以及您应该如何展示您的结果。幸运的是，AutoML 为您处理了所有这些考虑，使得训练一个多类模型与训练一个二分类模型一样简单。

在本节中，您将使用公开可用的 Iris 数据集加载数据。然后，您将为多类分类设置 AutoML 分类，训练并注册一个模型，并检查您的结果。您会注意到大部分代码与上一节相同。通过理解 AutoML 中二类和多类分类之间的差异，您将获得信心去应对任何类型的分类问题，无论其复杂程度如何。

从 GitHub 仓库下载Iris.csv文件，github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure。
按照与第三章**，训练你的第一个 AutoML 模型相同的步骤，将Iris.csv加载到 Azure 中，并创建一个名为Iris Training的数据集。

导入你将需要运行所有代码的所有库。注意，这些库与你在二分类中使用的库相同：

from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment
from azureml.core.compute import ComputeTarget
from azureml.train.automl import AutoMLConfig
from azureml.train.automl.run import AutoMLRun
from azureml.widgets import RunDetails

导入pandas和numpy。无论你处理什么数据，你都会发现这些包非常有用：
```
Import pandas as pd
import numpy as np
```
将你的 Jupyter 笔记本连接到你的 AMLS 工作区：
```
ws = Workspace.from_config()
```

设置你的计算集群：

compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)

设置你的datastore：

datastore = Datastore.get_default(ws)
my_datastore_name = 'workspaceblobstore'
my_datastore = Datastore.get(ws, my_datastore_name)

设置你的dataset。注意，这是与二分类不同的第一段代码，因为你正在使用一个完全不同的数据集：
```
dataset_name = "Iris Training"
dataset = Dataset.get_by_name(ws, dataset_name, version='latest')
```
使用以下代码查看你的数据的前 10 行。确保它看起来正确。在使用 Iris 数据时，你试图预测species列：
```
dataset.take(10).to_pandas_dataframe()
```
前十行应该类似于图 5.7：

图 5.7 – Iris 数据
使用 pandas 的unique函数在species列上查看你需要预测多少个类别。你应该看到三个类别，Iris-setosa，Iris-versicolor，和Iris-virginica：
```
dataset.to_pandas_dataframe().species.unique()
```
设置你的实验并给它命名：
```
experiment_name = 'Iris-Multi-Classification'
exp = Experiment(workspace=ws, name=experiment_name) 
```
尝试在命名你的实验时尽量描述性，以便于轻松追踪，例如，明确指出这次训练运行是为了多类分类。
将你的目标列设置为species。大小写很重要：
```
target_column = 'species'
```
与大多数自定义机器学习代码不同，你不需要将三个不同的类别转换为整数。AutoML 在后台处理所有这些。
为你的任务创建一个变量：任务是你要尝试训练的 AutoML 模型类型。对于预测类别，输入classification：
```
task = 'classification'
```
对于二分类和多类分类问题，task都应该设置为classification。
为你的主要指标创建一个变量。使用accuracy：
```
primary metric = 'accuracy'
```
对于二分类和多类分类问题，所有指标都是相同的，除了某些指标是通过平均每个类别的指标而不是简单地比较真阳性与真阴性来计算的不同。然而，准确率无论问题是否为二分类或多类分类，计算方式都是相同的。
为featurization创建一个变量并将其设置为auto：
```
featurization = 'auto'
```
你可以将featurization设置为auto或off。对于多类问题，将featurization设置为auto特别重要，以确保类别得到适当的平衡。如果不这样做，将影响模型性能。
将类别数设置为3：
```
num_classes = 3  
```
虽然你可以通过编程方式完成此操作，但在你已知并已确认类别数量时，你也可以将其设置为数字。

重要提示

当训练多类分类问题时，有时你应该硬编码类别的数量。这确保了如果损坏的数据进入你的系统并给你一个额外的、意外的类别，你的训练运行将失败。

配置你的 AutoML 运行。在配置运行本身方面，多类和二类分类问题之间没有区别。一个注意事项是，多类分类问题通常从稍微更高的交叉验证设置中受益。这有助于确保每个训练分割中的类别更加均匀。将其设置为 10：

config = AutoMLConfig(task=task,
                     primary_metric=primary_metric,
                     num_classes=num_classes,
                     featurization=featurization,
                     compute_target=compute_target,
                     training_data=dataset,
                     label_column_name=target_column,
                     experiment_timeout_minutes=15,
                     enable_early_stopping=True,
                     n_cross_validations=10,
                     model_explainability=True,
                     enable_stack_ensemble=True,
                     enable_voting_ensemble=True)

训练你的模型并实时查看结果：

AutoML_run = exp.submit(config, show_output = True)
RunDetails(remote_run).show()

一旦你的模型完成训练，注册你的模型：

description = 'AutoML Multiclass Run using Iris Data.' 
tags = {'project' : "Iris", "creator" : "your name"} 
model_name = 'Iris-Multi-Classification-AutoML' 
AutoML_run.register_model(model_name=model_name,description=\
description,tags=tags)

当你的 AutoML 模型运行时，它将执行通常的数据护栏检查，然后是。对于二类和多元分类，这是相同的，检查类别平衡、缺失特征和高基数。你的 Iris 数据应该轻松通过所有这些检查。

一旦数据护栏检查完成，AutoML 将像往常一样开始训练模型。比较在多类 Iris 数据上训练的模型与二类 Titanic 数据上训练的模型。你应该注意到大多数模型是相同的。你的输出应该类似于 图 5.8：

图 5.8 – 多类分类的 AutoML 结果

结果非常出色。AutoML 在 Iris 数据集上表现异常出色。还有一种简单的方法可以直接从你的 Jupyter 笔记本中绘制你的性能。将鼠标稍微向下滚动到你的模型输出之后，直到你看到指向每个模型的蓝色链接，如图 图 5.9 所示。点击你表现最好的模型。对于示例，它是投票集成模型，但你的情况可能不同：

图 5.9 – 模型链接

点击此链接将展示大量针对你的 AutoML 分类实验的可视化。特别是，有一个 精确率-召回率曲线、一个 ROC 曲线、一个 提升曲线、一个 增益曲线、一个 校准曲线 和一个 混淆矩阵。商业用户最容易理解混淆矩阵，它显示了准确分类的类别数量以及错误分类的数量。如图 图 5.10 所示，AutoML 只错误地将 150 个数据点中的两个分类错误。在两种情况下，模型错误地将 Iris-versicolor 分类为 Iris-virginica：

图 5.10 – Iris 分类模型的混淆矩阵

现在您已经使用 AutoML 训练了二进制和多类分类模型，您可以将这些技术应用到您自己的数据和业务问题上。如果您正在训练定制的机器学习模型，您将不得不记住二进制和多类分类之间许多小的差异，但 Azure AutoML 为您处理了所有这些复杂性。您甚至不需要将分类列转换为整数。

因此，您应该对使用 AutoML 解决任何分类问题感到舒适。最后一节为您提供了提高模型性能的技巧和窍门。

微调您的 AutoML 分类模型

在本节中，您将首先回顾提高您的 AutoML 分类模型的技巧和窍门，然后回顾 AutoML 用于二进制和多类分类的算法。

提高 AutoML 分类模型

记住第四章中的技巧和窍门构建 AutoML 回归解决方案，以下是一些特定于分类的新技巧：

与回归问题不同，在现实世界中，几乎所有分类问题都需要你权衡你的目标列。原因是，对于大多数商业问题，一个类别几乎总是比其他类别更重要。

例如，假设您正在经营一家企业，您试图预测哪些客户会停止与您做生意，转而与竞争对手合作。这是一个常见的称为客户流失或客户周转的问题。如果您错误地将客户识别为可能流失，您浪费的只是一个不必要的电话或电子邮件。然而，如果您的算法错过了一个即将流失的客户，您就会失去那个客户及其资金。

如果您在 AutoML 中使用正常准确率指标，那么对于这个问题来说，这是一个很差的指标。这是因为将某人误认为是可能转换的人，比误认为是可能留下的人要好得多。解决这个问题的方法是使用 AutoML 中的weight_column_name功能。这允许您创建一个对命中和失误进行不同权重的列。

例如，如果您的算法错过了一个可能流失的客户，您可以比算法错误地表示客户将流失而实际上不会流失时，对该失误进行 100 倍的惩罚。将流失客户的权重设置为 100，未流失客户的权重设置为 1。这将训练出一个在不会错过即将流失的客户方面表现优异的模型，尽管它也会有大量的误报。
熟悉所有 AutoML 分类配置选项。您可以在以下链接中找到它们：docs.microsoft.com/en-us/python/api/azureml-train-automl-client/azureml.train.automl.automlconfig.automlconfig?view=azure-ml-py。
如果你的目标列的比率超过 20 比 1，收集更多来自较小类别的数据或重新采样你的数据以达到 20 比 1 的比率是一个好主意。
研究五种不同的主要指标，以了解哪些指标最适合你的问题。分类需要更深入地理解业务问题，以便做出明智的指标选择。
使用docs.microsoft.com/en-us/azure/machine-learning/how-to-understand-automated-ml来了解一个好的分类模型是什么样的。混淆矩阵在确定你的模型是否更擅长预测一个类别而不是另一个类别时特别有价值。根据你的业务用例，这可能是也可能不是一个问题。
在 AML studio 中，转到资产下的实验，点击你的实验名称，选择运行 ID，点击模型标签，选择性能最高的算法，然后点击指标标签。这将为你提供评估算法所需的所有不同指标和图表。
探索使用weight_column_name配置选项来权衡你的数据。理解这一点非常重要。如果某些观察结果比其他观察结果更重要，你应该始终为这些观察结果分配更高的权重。

这对于分类模型尤其重要，因为如前所述，某些观察结果几乎总是比其他观察结果更重要。尝试使用泰坦尼克号数据将0.1分配给幸存者，将1分配给受害者来构建模型。然后，尝试相反的操作。
过拟合，即你产生了一个非常好的模型，但不能推广到新的数据点，在分类和回归中都是一个同样的问题。如果你遇到这种情况，尝试添加更多历史数据或从你的数据集中删除列。如果你的目标列有超过 2 个类别，尝试将其分箱以创建一个更不易过拟合的简单模型。
在处理分类问题时，要注意模型偏差。偏差可能发生在你的模型为了另一个类别牺牲了一个类别的性能时。最糟糕的偏差发生在模型只预测一个类别的情况下，例如，总是预测泰坦尼克号乘客死亡。这些模型有时由于类别不平衡而可能非常准确。在泰坦尼克号数据中，这样的模型准确率可达 61.6%。
当处理大型数据集时，你的计算实例的大小并不重要，但你的计算集群的大小非常重要。这是因为你的计算实例仅用于编写和提交代码，而 AutoML 训练作业是在计算集群上远程运行的。确保你使用适当大小的虚拟机（VM）来训练 AutoML 非常重要。
你计算集群上虚拟机的大小应该由用于训练的数据集大小决定。大致来说，你的虚拟机 RAM 应该是你以未压缩 CSV 格式训练的数据大小的 20 倍，或者是在 pandas DataFrame 中训练的数据大小的两倍。这是因为 CSV 文件在转换为 DataFrame 时大小会增长到原来的 10 倍。这保证了运行过程的顺畅。

例如，如果你的基础 CSV 文件大小为 5 GB，那么你计算集群中每个虚拟机的 RAM 至少应该是 100 GB。相比之下，如果你的数据在转换为 pandas DataFrame 后大小为 5 GB，那么你只需要具有 10 GB RAM 的虚拟机。
AutoMLConfig有许多选项，你应该熟悉它们。其中一个选项是max_cores_per_iteration。将其设置为-1，以便每个模型训练运行充分利用每个虚拟机上的所有核心，给你提供更多的处理能力。
你可以通过另一个名为max_concurrent_iterations的AutoMLConfig选项并行训练 AutoML 模型。这决定了 AutoML 并行训练多少个模型。将此设置为计算集群上的最大节点数。如果你计算集群上有 8 个节点，并将max_concurrent_iterations设置为8，那么 AutoML 将一次训练 8 个模型。

这些只是你可以使用 AutoML 微调分类模型的好几种方法中的一部分。你可以通过阅读机器学习的科学文章、博客文章和教程来学习更多技术。当然，没有什么能比经验更宝贵了。

尝试下载尽可能多的开源分类数据集，将它们加载到 Azure 中，并使用它们来训练和微调 AutoML 模型。经验带来智慧，智慧带来使用自动化机器学习技术解决甚至最棘手商业问题的能力。了解 AutoML 分类算法的细节对于你发展数据科学知识也是非常重要的。

理解 AutoML 分类算法

AutoML 用于分类的许多算法与用于回归的算法相同。与回归一样，某些算法在特定情况下表现更好。与回归不同，AutoML 在分类中使用了更多种类的算法，包括神经网络。

AutoML 用于分类的树、梯度提升和最近邻算法与用于回归的算法相同，你可以在第四章“构建 AutoML 回归解决方案”中查看它们。唯一的区别是，分类版本预测的是概率而不是值。随机梯度下降（SGD）也被 AutoML 用于分类。独特的分类算法包括逻辑回归、朴素贝叶斯、平均感知器分类器和三种使用支持向量机（SVM）的算法。

逻辑回归使用逻辑函数，一个 s 形的 sigmoid 曲线，来模拟你的数据属于某一类别的概率。尽管其名称如此，它与回归无关。与用于回归的弹性网络类似，逻辑回归通过调整输入变量的系数来使用L1（lasso）和L2（ridge）正则化创建更简单的模型。逻辑回归简单易用，但它在处理小数据集或数据具有非线性关系时表现不佳。

朴素贝叶斯是另一种简单的分类算法。它使用贝叶斯定理来计算给定数据行中每个输入特征的类别概率。然后，在决定类别时，它对每个输入特征给予相同的权重。它之所以被称为“朴素”，是因为它假设输入特征之间相互独立。朴素贝叶斯即使在数据量小的情况下也能表现良好，但它在现实生活中的主要假设——独立性——几乎总是被违反。

平均感知器分类器是一种简单的神经网络类型，它使用一组权重和线性函数来做出预测。与逻辑回归类似，它最适合具有输入变量和目标列之间线性关系的数据库。它仅用于二元分类。

支持向量算法通过在数据超平面上绘制分割来对数据进行分类。想象一下，在你的输入列数 n 的 n 维空间中可视化你的数据。SVM 通过找到最佳划分数据的线来工作。它们适用于线性和非线性数据，甚至适用于高维数据。AutoML 使用这三种算法中的三种：支持向量分类（SVC）、线性 SVC 和线性 SVM 分类器。

SVC 是支持向量机的一个标准实现，适用于多类和二元分类问题。线性 SVC 是一种将数据线性划分的实现，与可以使用非线性核函数划分数据的 SVC 不同。另一方面，线性 SVM 分类器与线性 SVC 相似，但只能用于二元分类。

以下表格提供了 14 种算法的总结：

图 5.11 – AutoML 分类算法

与回归类似，AutoML 在每个 AutoML 训练运行的末尾执行模型集成。投票集成通过取预测类别概率的加权平均来预测单个输入数据行的类别。相比之下，堆叠集成使用其他模型的输出训练逻辑回归模型。通常，这两种集成模型中的任何一个都将是你的最佳模型。

关于这些模型的更多信息，请参阅位于docs.microsoft.com/en-us/azure/machine-learning/how-to-configure-auto-train#configure-your-experiment-settings的 AutoML 文档。

摘要

你已经通过使用 AML Python SDK 成功训练了一个分类模型，丰富了你的技能库。你已加载数据，使用 pandas 和 Numpy 进行了大量转换，并构建了一个玩具 AutoML 模型。然后，你将该模型注册到你的 AMLS 工作区。

你现在可以使用自己的数据开始构建分类模型。你可以轻松解决二元和多类分类问题，并且你可以通过混淆矩阵以他们理解的方式展示结果。许多最常见的商业问题，如客户流失，都是分类问题，而通过本章所学到的知识，你可以解决这些问题，并在你的组织中赢得信任和尊重。

下一章，第六章**，构建 AutoML 预测解决方案，将与前两章有很大不同。与分类和回归问题相比，预测问题有更多的设置需要使用和理解，并且它们总是要求你对你的数据集有更深入的了解。新手数据科学家在训练此类模型时也会犯许多错误，而 AutoML 将使你避免所有这些错误。

第六章: 构建一个 AutoML 预测解决方案

在构建了 AutoML 回归和分类解决方案之后，你现在准备好解决一个更复杂的问题：预测。预测本质上比分类或回归复杂得多。那两种机器学习（ML）问题类型假设时间是不相关的。无论时间过去多久，你的糖尿病模型总是能够准确预测谁的病情会随着时间的推移而恶化。你的泰坦尼克号模型总是能够预测谁会生存谁会死亡。相比之下，在预测问题中，你总是试图根据过去的事件来预测未来的事件；时间总是你模型中的一个因素。

你将像开始第四章，构建一个 AutoML 回归解决方案和第五章，构建一个 AutoML 分类解决方案一样开始这一章。首先，你将导航到你的 Jupyter 环境，加载数据，训练一个模型，并评估结果。你将学习两种本质上不同的使用 AutoML 训练预测模型的方法。一种方法仅使用ARIMA和Prophet算法；另一种方法使用所有其他可用的算法。

在本章结束时，你将学习如何通过调整 AutoML 设置来微调你的预测模型；有许多特定于预测的设置，因此你将花费大量时间来覆盖它们的各种用例。

到本章结束时，你将能够使用 AutoML 训练预测模型而不会出错。与其他技术相比，预测问题更容易出错，所以这是一个相当大的成就。你将了解如何转换和安排你的数据以进行预测，以及如何调整 AutoML 设置以产生更准确、更可靠的模型，巩固你在 Azure AutoML 方面的专业知识。

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

准备 AutoML 预测数据
训练一个 AutoML 预测模型
注册你的训练好的预测模型
微调你的 AutoML 预测模型

技术要求

与第四章，构建一个 AutoML 回归解决方案一样，你将在运行在 Azure 计算实例上的 Jupyter 笔记本中用 Python 代码创建和训练模型。因此，你需要一个有效的互联网连接，一个Azure 机器学习服务（AMLS）工作区和一个计算实例。同样，当你继续在笔记本上工作时，你需要一个可工作的计算集群来远程训练模型。完整的要求列表如下：

访问互联网。
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium。
一个 Microsoft Azure 账户。
你应该已经创建了一个 AMLS 工作区。
你应该已经创建了一个计算实例。
你应该在 第二章，Azure Machine Learning 服务入门 中创建了计算集群。
你应该了解如何从 Azure 计算实例导航到 Jupyter 环境，如 第四章，构建 AutoML 回归解决方案 中所示。

本章的代码在此处可用：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/tree/master/Chapter06。

准备 AutoML 预测数据

预测与分类或回归非常不同。回归或分类的机器学习模型基于一些输入数据预测某些输出。另一方面，预测的机器学习模型基于过去发现的模式预测未来状态。这意味着在塑造数据时，你需要注意一些关键的时间相关细节。

对于这个练习，你将使用 OJ Sales Simulated Data Azure 开放数据集进行预测。与用于回归的 Diabetes Sample Azure 开放数据集类似，OJ Sales Simulated Data 只需拥有 Azure 账户即可获取。你将使用这些数据创建一个模型，预测不同品牌和商店未来橙汁的销售情况。

有一个额外的关键区别；OJ Sales Simulated Data 是一个 文件数据集，而不是 表格数据集。虽然表格数据集由一个包含列和行的文件组成，但文件数据集由许多文件组成，可以是表格或其他类型。

就像你在 AMLS 工作区中执行的所有其他编码工作一样，你将首先从计算实例打开 Jupyter，创建一个新的 Jupyter 笔记本。然后，你将加载数据，将其转换为 pandas 数据框，并将其注册为数据集，这样你就可以使用它来训练一个 AutoML 机器学习模型。

导航到你的 Jupyter 环境

你将按照以下步骤开始创建一个新的 Jupyter 笔记本：

首先，通过导航到 ml.azure.com 打开你的 Azure Machine Learning (AML) 工作室。
从左侧面板点击 Compute。
选择你的计算实例。如果它没有运行，请点击 Start。

重要提示

在 Azure 上工作以节省金钱时，当你不使用计算实例时请关闭它。计算实例按小时计费。
点击 Jupyter 进入你的 Jupyter 环境。
通过点击屏幕右侧的 New 创建一个新的 Jupyter 笔记本，并选择 Python 3.6 – AzureML。由于更新，Python 的版本可能不同。
将你的 Jupyter 笔记本重命名为 OJ Forecasting_AutoML。如果你需要复习如何这样做，请参阅 第四章，构建 AutoML 回归解决方案。

在创建好笔记本之后，你现在可以准备加载橙汁销售数据，并用 Python 进行转换。

加载数据和转换数据

现在是时候使用你的数据了，按照你在第四章，构建 AutoML 回归解决方案和第五章，构建 AutoML 分类解决方案中使用的模式进行操作。本节的目的是从包含许多文件的文件数据集中提取一个子集，将所有文件合并在一起，并创建一个新的表格数据集。执行以下步骤：

使用以下代码加载你需要的所有 Azure 库：
```
from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment
from azureml.core.compute import ComputeTarget
from azureml.train.automl import AutoMLConfig
from azureml.train.automl.run import AutoMLRun
from azureml.widgets import RunDetails
from azureml.opendatasets import OjSalesSimulated
from azureml.automl.core.forecasting_parameters import ForecastingParameters
```
你应该能识别出从第四章，构建 AutoML 回归解决方案中提到的Workspace、Dataset、Datastore、Experiment、ComputeTarget、AutoMLConfig、AutoMLRun和RunDetails。

OjSalesSimulated允许你通过ForecastingParameters直接访问OJ Sales Simulated Data Azure Open Dataset，对于 AutoML 预测任务来说，这是必要的，因为你不能简单地将预测特定的参数传递给AutoMLConfig对象。你必须首先将它们分配给ForecastingParameters，然后将这些参数传递到你的 AutoML 配置中。

重要提示

如果你加载任何 Azure 库时遇到问题，请通过运行此处找到的Update AzureML SDK.ipynb笔记本来更新 Azure ML SDK：https://github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Update-AzureML-SDK.ipynb。
使用以下代码加载pandas、numpy、os和path：
```
import pandas as pd
import numpy as np
import os
from pathlib import Path
```
你应该能从第四章，构建 AutoML 回归解决方案中识别出pandas和numpy。os和Path对你来说将是新的。这些包允许你在 Jupyter 笔记本中创建和操作文件和文件夹。此外，当与OjSimulatedSales等文件数据集一起工作时，它们是必要的，可以将它们转换为 AutoML 训练的表格数据集。
将你的 Jupyter 笔记本连接到你的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果你被提示登录，请按照指示进行操作。
设置你的计算集群：
```
compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)
```
你在第二章，Azure 机器学习服务入门中创建了此计算集群。
设置你的数据存储。对于这个练习，我们将使用与你的 AMLS 工作区一起提供的默认数据存储：
```
datastore = Datastore.get_default(ws)
```
使用此代码从OJ Sales Simulated Data中拉取10个文件：
```
oj_sales_files = OjSalesSimulated.get_file_dataset()
oj_sales = oj_sales_files.take(10)
```
重要技巧

OJ Sales Simulated Data Azure Open Dataset 中有超过 4,000 个文件。拉取所有这些文件可能会导致训练时间延长。
使用以下代码创建一个文件夹，以便将文件下载到你的 Jupyter 环境中：
```
folder_name = "OJ_Sales"
os.makedirs(folder_name, exist_ok=True)
```
为了使用文件数据集，你首先需要将它们下载到你的本地 Jupyter 环境中。然后，你可以通过连接文件来将它们作为 pandas dataframe 读取。
使用以下代码将 10 个文件下载到您新创建的OJ_Sales文件夹：
```
oj_sales.download(folder_name, overwrite=True)
```
如果您在 Jupyter 环境中导航到OJ Sales文件夹，您应该在运行此代码后看到那里的文件。
使用以下代码将 10 个文件作为一个单独的 pandas 数据框读取：
```
OJ_file_path = Path('OJ_Sales').rglob('*.csv')
OJ_files = [x for x in OJ_file_path]
df = pd.concat((pd.read_csv(f) for f in OJ_files))
```
为了实现这一点，我们需要使用Path包来指定文件夹和文件扩展名，以及pandas将 10 个文件合并成一个单一的数据框。请注意，此代码将读取您OJ Sales文件夹中的所有内容。请不要在此文件夹中放置其他文件，否则将损坏此部分的代码。
查看您数据的前 10 行。确保其看起来正确：
```
df.head(10)
```
橙汁销售数据有七个列：WeekStarting、Store、Brand、Quantity、Advert、Price和Revenue。Advert表示该周是否有针对该品牌橙汁的广告活动。其他列是自解释的。数据的前 10 行如下所示：

图 6.1 – 查看您的橙汁销售数据集
将您的 pandas 数据框注册为数据集：
```
Dataset.Tabular.register_pandas_dataframe(df, datastore,
                            "OJ Sales Sample")
```
虽然将文件数据集注册为表格数据集可能看起来很奇怪，但表格数据集本身更容易处理。文件数据集只是指向包含大量文件的文件夹的指针；在使用它们之前，必须在文件上执行大量数据预处理工作。另一方面，表格数据集是格式化的，并准备好与 AutoML 立即使用。

在这里，重要的是要注意WeekStarting的主要区别。时间列需要某种定期的节奏，例如每天、每周、每月或每年。在这种情况下，是每周四。

某些算法，如Prophet和ARIMA，要求您拥有一个无间隔的时间列。其他 AutoML 算法可以处理间隔，但前提是您在目标列中未启用某些功能，例如时间滞后。

重要提示

时间列中的间隔也会阻止您使用某些特定于预测的功能，特别是目标列的滞后和这些滞后的移动平均。这些功能通常可以提高性能。仔细研究您的数据，以消除间隔以在预测解决方案中获得最佳性能。

时间序列数据的其他基本元素是您的Store和Brand是您的粒度列；每个商店和品牌的组合都有单独的时间序列。

如果 AutoML 在单个粒度上检测到多个时间序列，它将自动失败。换句话说，您不能为单个粒度有重复的日期。因此，在使用 AutoML 预测时，仔细研究您的数据，以消除同一粒度上的重复日期。

考虑到这些因素，您现在可以训练一个 AutoML 预测模型。首先，您将训练一个不使用ARIMA和Prophet的模型。然后，您将使用这两个算法训练一个模型。

训练 AutoML 预测模型

训练 AutoML 预测模型与训练 AutoML 回归模型最为相似。与回归不同，而与分类不同，你试图预测一个数字。与回归不同，这个数字总是基于过去发现的模式在未来。此外，与回归不同，你可以预测一系列数字到未来。例如，你可以选择预测未来一个月，或者你可以选择预测 6 个月、12 个月、18 个月甚至 24 个月。

重要提示

你尝试预测的时间越远，你的预测模型就越不准确。

按照你在第四章，“构建 AutoML 回归解决方案”和第五章，“构建 AutoML 分类解决方案”中看到的相同步骤进行。首先，为你的实验设置一个名称。然后，设置你的目标列和 AutoML 配置。

对于预测，还有一个额外的步骤：设置你的预测参数。这是你设置时间列、粒度列和滞后设置的地方。然后，这些设置需要作为单个预测参数对象传递到你的 AutoML 配置中。一旦完成这一步，你才能使用 AutoML 来训练一个预测模型。

在本节中，你将重复这个过程两次，首先是通过使用 AutoML 中可用的标准预测算法正常训练一个模型，其次，你将使用略微不同的设置来启用 ARIMA 和 Prophet，并比较两个 AutoML 模型的性能。

使用标准算法训练预测模型

要使用 AutoML 训练你的预测模型，请按照以下步骤操作，继续在OJ 预测 AutoML Jupyter 笔记本中：

使用以下代码设置你的实验并给它命名：
```
experiment_name = 'OJ-Sales-Forecasting'
exp = Experiment(workspace=ws, name=experiment_name)
```
有一个重要的事情要记住，一个实验可以是一组多个训练运行，而不仅仅是一个单独的训练运行。换句话说，我们可以在同一个实验名称下使用不同的设置来训练多个模型。

使用以下代码检索你的OJ 销售样本数据集：

dataset_name = "OJ Sales Sample"
dataset = Dataset.get_by_name(ws, dataset_name, version='latest')

将你的目标列设置为数量：
```
target_column = 'Quantity'
```
在 Python 中，大小写很重要；请记住这一点。
为你的 AutoML 任务创建一个变量。task是你试图训练的 AutoML 模型类型。要预测未来的数字，输入forecasting：
```
task = 'forecasting'
```
重要说明

将预测问题作为回归问题来训练总是不正确的。尽管它们在名义上都做同样的事情，即预测一个数字，但预测需要更加谨慎的方法，以避免在训练模型时包含未来的值。用于回归的标准交叉验证方法不适用于预测问题，因此请确保将task设置为forecasting。
为你的主要指标创建一个变量。主要指标是评估你的模型的方式。使用 标准化均方根误差（normalized RMSE）。此指标将预测值从每个观察的实际值中减去，然后平方，并平均所有观察值的分数。分数越低，你的模型越好。预测的其他选项包括 R2 分数、Spearman 相关系数和 标准化平均绝对误差（normalized MAE）。请注意，这些与回归指标相同：
```
primary_metric = 'normalized_root_mean_squared_error'
```
为 featurization 创建一个变量。你可以将 featurization 设置为 auto 或 off。设置为 auto：
```
featurization = 'auto'
```
如果你将 featurization 设置为 off，你将不得不删除高基数特征，填充空值，对数据进行独热编码，并自己生成额外的特征。当将 featurization 设置为 auto 时，AutoML 会自动为你处理这些。
在预测中，特征化也会从你的时间列创建各种日期/时间特征，包括年份、月份、星期、星期几、上午/下午和一天中的小时。除非你是能够自己完成所有工作的专家数据科学家，否则始终将 featurization 设置为 auto。

设置你的预测参数。这些参数有很多，我们将逐一介绍如下：

a) country_or_region_for_holidays 决定了使用哪个国家来生成表示不同国家假日的列。你可以将此参数设置为无、单个国家或国家列表。设置为 US 以表示美国。你将为每个假日得到一个单独的列。

b) drop_columns_names 允许你在训练预测模型之前输入要删除的列的列表。在这里删除 Revenue 列，因为它部分来自你的目标列 Quantity。
```
params=\
ForecastingParameters.from_parameters_dict( 
{'country_or_region_for_holidays':'US',\
                'drop_columns_names':'Revenue',\
                'forecast_horizon': 6,\
                'target_rolling_window_size': 'auto',\
                'target_lags': 'auto',\
                'feature_lags': 'auto',\
                'seasonality': 'auto',\
                'short_series_handling': True,\
                'use_stl': 'season_trend',\
                'time_column_name':'WeekStarting',\
                'time_series_id_column_names':\
                ['Store','Brand'],\
               'short_series_handling_configuration':\
                'auto'},\
                validate_params=True)
```
重要注意事项

有相当多的特定于预测的参数。花时间通过阅读以下位置的 Azure AutoML ForecastingParameters 文档来深入了解这些设置：docs.microsoft.com/en-us/python/api/azureml-automl-core/azureml.automl.core.forecasting_parameters.forecastingparameters?view=azure-ml-py。

配置你的 AutoML 运行。在这里，你需要传入你的任务、主要指标、特征化设置、计算目标、数据集、目标列和预测参数。所有这些你之前都已经创建好了。你还需要传入实验将运行多长时间，如果模型性能没有提高，是否将提前停止，交叉验证的次数，以及模型可解释性设置。

此外，你将决定是否使用3个拆分；与分类或回归不同，当将交叉验证设置为较低数值时，预测运行更准确。这是由于 AutoML 将数据拆分为不同集合以评分性能的本质：

config = AutoMLConfig(task=task,
                     primary_metric=primary_metric,
                     featurization=featurization,
                     compute_target=compute_target,
                     training_data=dataset,
                     label_column_name=target_column,
                     experiment_timeout_minutes=15,
                     enable_early_stopping=True,
                     n_cross_validations=3,
                     model_explainability=True,
                     enable_stack_ensemble=False,
                     enable_voting_ensemble=True,
                     forecasting_parameters=params)

重要提示

False。这与回归或分类不同。

训练你的模型并实时查看结果：

AutoML_run = exp.submit(config, show_output = True)
RunDetails(AutoML_run).show()

如前所述，启动你的 AutoML 运行，为自己泡杯咖啡，然后回来实时观看模型训练。你会看到一个数据边界检查，如图图 6.2所示。注意它如何用于预测：

图 6.2 – 预测的数据边界检查

首先，数据边界将检查你的时间列，以确保所有数据点都与正确的频率对齐。对于你的OJ 销售样本数据，这意味着确保每个数据点都落在星期四，并且每周间隔 1 周。

然后，数据边界将以与分类和回归相同的方式进行缺失值插补。在这里，任何列中都没有缺失值。最后，它将寻找训练设置中时间序列太短的情况。如果 AutoML 检测到短序列，它将创建更简单的模型来处理这些情况。

完成数据边界检查后，AutoML 将开始使用不同的特征转换、算法和超参数组合来训练模型。如果没有除了时间列、粒度列和目标列之外的其他特征，它将除了其标准的预测模型套件外，还会训练 ARIMA 和 Prophet 模型。你的输出应该类似于图 6.3：

图 6.3 – 预测的 AutoML 结果

使用 Prophet 和 ARIMA 训练预测模型

预测与其他两种 AutoML 问题类型的一个重要区别是 Prophet 和 ARIMA 算法。Prophet 和 ARIMA 与所有其他算法本质上不同，因为为了训练它们，你只需要粒度列、目标列和时间列。仅此而已。添加任何其他列都将限制 AutoML 使用这些算法。

Prophet 与 ARIMA 的不同之处在于，它们只使用目标列中找到的模式进行预测。其他变量被忽略。有时，它们会优于其他算法；有时则不会。不尝试很难知道。

由于很难知道 ARIMA 和 Prophet 相对于其他算法的表现如何，建议如果你有时间，总是尝试训练它们。也就是说，如果你的时间序列数据在时间列中没有缺失，总是首先训练 ARIMA 和 Prophet 模型作为你的基线。它们需要更长的时间来训练，所以建议你增加你的实验超时时间，特别是对于更大的数据集。

使用 ARIMA 和 Prophet 构建 AutoML 预测解决方案的步骤如下：

从上一节复制步骤 1-6，直到你到达预测参数。

在预测参数中，移除所有的特征列，只留下你的时间、粒度和目标列。此外，通过将它们设置为None来关闭所有 AutoML 生成的特征，如节假日、特征滞后和目标滞后，如下面的代码块所示：

params=\
ForecastingParameters.from_parameters_dict(\
{'country_or_region_for_holidays':None,\
                  'drop_columns_names':\
                  ['Revenue','Price','Advert'],\
                  'forecast_horizon': 6,\
                  'target_rolling_window_size': None,\
                  'target_lags': None,\
                  'feature_lags': None,\
                  'seasonality': 'auto',\
                  'short_series_handling': True,\
                  'use_stl': 'season_trend',\
                  'time_column_name':'WeekStarting',\
                  'time_series_id_column_names':\
                  ['Store','Brand'],
               'short_series_handling_configuration':\
                  'auto'},\
                  validate_params=True)

特征滞后和目标滞后通过创建额外的变量来工作。这就是为什么为了使 AutoML 能够运行 Prophet 和 ARIMA，它们需要从你的数据中移除。

按照你在步骤 8中做的那样配置你的 AutoML 运行，传递你的更新后的预测参数。

训练你的模型并实时查看结果：

Prophet_ARIMA_run = exp.submit(config, show_output = True)
RunDetails(Prophet_ARIMA_run).show()

重新运行 AutoML 后，你的结果应该类似于图 6.4。注意，对于这个问题，ARIMA 和 Prophet 没有返回更好的结果，并且投票集成通常优于所有模型：

图 6.4 – 使用 ARIMA 和 Prophet 的 AutoML 预测结果

你现在已经使用OJ Sales Sample数据训练了两套模型，并实现了相当低的标准化 RMSE。你现在可以进入下一节注册你的模型。注册的模型对于以后在 ML 管道或实时端点中评分新数据是必要的。

注册你的训练好的预测模型

注册预测模型的代码与你在第四章中使用的代码相同，构建一个 AutoML 回归解决方案，以注册你的回归模型，以及在第五章中使用的代码，构建一个 AutoML 分类解决方案，以注册你的分类模型。始终注册新模型，因为根据你的业务场景，你将在实时评分端点或批量执行推理管道中使用它们。同样，始终添加标签和描述以方便跟踪：

首先，给你的模型起一个名字，一个描述，以及一些标签。标签让你可以轻松地搜索模型，所以在实现时要仔细思考：

description = 'Best AutoML Forecasting Run using OJ Sales Sample Data.' 
tags = {'project' : "OJ Sales", "creator" : "your name"} 
model_name = 'OJ-Sales-Sample-Forecasting-AutoML'

接下来，将你的模型注册到你的 AMLS 工作区，传递你的模型名称、标签和描述。使用你在训练一个 AutoML 预测模型部分中训练的AutoML_run模型：
```
AutoML_run.register_model(model_name=model_name, description=description, tags=tags)
```

尝试根据 R2 分数注册不同的模型。给它一个稍微不同的名字，添加一个额外的标签，并使用相同的描述：

description = 'Best AutoML Forecasting Run using OJ Sales Sample Data.'
tags = {'project' : "OJ Sales", "creator" : "your name", "metric" : "R2 Score"} 
model_name = 'OJ-Sales-Sample-Forecasting-AutoML-R2'
AutoML_run.register_model(model_name=model_name, description=description, tags=tags, metric = 'r2_score')

在某些情况下，您将执行 AutoML 训练运行，但您会忘记注册模型。不要担心。您可以使用实验名称和运行 ID 检索 AutoML 训练运行，并从那里注册模型。请使用以下代码：

experiment_name = 'OJ-Sales-Forecasting'
exp = Experiment(workspace=ws, name=experiment_name) 
AutoML_run = AutoMLRun(experiment = exp, run_id = 'your_run_id') 
description = 'Retrieved AutoML Forecasting Run for OJ Sales Data.'
tags = {'project' : "OJ Sales", "creator" : "your name"} 
model_name = 'OJ-Sales-Sample-Forecasting-AutoML-Retrieved'
AutoML_run.register_model(model_name=model_name, description=description, tags=tags)

您现在已注册了预测模型，并且它已准备好使用。您可以使用它来预测未来 6 周内各种商店和品牌的橙汁需求。您还可以以多种方式对其进行修改，例如预测 3 周、12 周或仅仅是下周的销售情况。

预测是一门艺术，比分类或回归更为复杂，这使得下一节的内容尤为重要：微调 AutoML 预测模型的小技巧和窍门。

微调您的 AutoML 预测模型

在本节中，您将首先回顾提升您的 AutoML 预测模型的小技巧和窍门，然后回顾 AutoML 用于预测的算法。

提升 AutoML 预测模型

预测很容易出错。一个模型可能在开发阶段看起来似乎有效，但一旦部署到生产环境中，就无法做出准确的预测。许多数据科学家，即使是经验丰富的，也会犯错误。虽然 AutoML 可以帮助您避免一些常见的错误，但还有一些错误需要您谨慎行事。为了避开这些陷阱并制作出尽可能好的模型，请遵循以下小技巧和窍门：

您用任何特征列进行训练时，都必须在您进行预测时可用。对于OJ Sales Sample，这意味着如果您想预测 6 周后的销售数量并将价格作为输入变量，您需要知道每个产品 6 周后的价格。

请与您的商业伙伴和 IT 人员确认，以了解您将有哪些数据可用于进行预测。如果您无法在尝试预测的时间框架内知道特征列的值，请从您的训练数据集中删除该列。
标准交叉验证技术不适用于预测。如果您试图进行未来状态预测，AutoML 使用task设置为forecasting。将其设置为回归可能会给您一些结果，但由于它们忽略了时间成分，因此这些结果将没有意义。
熟悉所有不同的 AutoML 预测配置选项。您可以在以下链接中找到它们：docs.microsoft.com/en-us/python/api/azureml-train-automl-client/azureml.train.automl.automlconfig.automlconfig?view=azure-ml-py。
总是首先尝试仅使用 ARIMA 和 Prophet 构建预测模型。这两个模型提供了一个良好的基线，因为它们只使用您的时间列和目标列来构建机器学习模型。如果使用额外特征的模型没有优于 ARIMA 和 Prophet，那么您知道这些额外特征与您的业务问题不相关。从您的数据集中删除这些特征。
在决定预测范围时，请仔细思考。通常，预测算法在预测短期范围时表现更好，无论是下一个或两个时间段。当预测更长的范围时，您应该预期准确性会随着预测范围的扩大而降低。了解这一点后，当您的业务伙伴要求您预测很多时间段时，请向他们提出反对意见。

一般而言，人们总是想知道未来，而且您能预测得越远，他们就越高兴。请解释他们应该比长期预测更信任短期预测。
当现状与过去相似时，预测未来效果最佳。冲击事件通常会破坏甚至表现良好的预测模型。当这种情况发生时，尝试仅使用最近的数据点来训练模型。这是一个迭代过程，因为通常很难判断哪些训练点仍然相关。

在某些情况下，最好的做法是仅使用冲击事件开始的数据来训练模型。例如，许多商店在冠状病毒大流行期间与疫情前的条件相比，经历了截然不同的产品需求。
当冲击事件过去，事情恢复正常时，尝试使用 AutoML 中的加权列特征来训练预测模型。将冲击事件期间的时间段设置为0。

记住，不应在时间列存在空缺的情况下训练 AutoML 预测模型。然而，在冲击事件期间发生的数据点与正常情况不相关。通过使用加权列并将权重设置为0和1，您可以训练一个有效地忽略冲击事件而不违反无空缺规则的预测模型。
同样，使用权重列来更重视近期数据而不是更远期的数据。对于许多问题，近期数据比过去数据更相关。采访您的业务伙伴，找到您的行业发生变革的关键日期。
此外，只有当过去的情况与现在的情况相似时，更多的数据才能帮助预测模型。当您仅使用最近的相关数据来训练模型时，预测模型通常会产生更好的结果。不要害怕丢弃那些对预测当前情况帮助太小的过去数据点。

再次强调，通过采访业务伙伴来找到您的行业经历重大变革的关键日期。丢弃在重大变革之前发生的数据通常会生成更优的模型。
预测非常挑剔，比回归或分类问题更挑剔。这是因为公司喜欢预测的事物类型是由市场需求和人们的需求驱动的，而人们的需求往往会发生变化。市场上流行的东西可能会在几乎没有预警的情况下迅速变化，因此，预测模型需要不断地重新训练，每次获取最新数据时都要这样做。
当你使用 AutoML 训练的预测模型进行预测时，它总是从预测下一个时间段的值开始。正因为如此，当你评分数据时，你的数据必须从下一个时间段开始。例如，如果你在一个以 1 月 5 日结束的数据上训练了一个日预测模型，你的评分数据必须从 1 月 6 日开始。
如果你的时间列以 2 月结束，并且你正在预测两个时间段的值，AutoML 将预测 3 月和 4 月。你不能使用该模型来预测 5 月或 6 月。为了做到这一点，你必须使用结束日期更晚的训练数据重新训练模型。因此，你需要不断地重新训练 AutoML 预测模型，以确保你的预测是最新的。
为了确定季节性，在使用 AutoML 之前，将目标列绘制出来，寻找任何重复的季节性模式。这将让你知道是否应该使用季节性特征。
当你试图在全球范围内进行预测时，确保在生成假日特征时包含所有国家。假日通常在预测需求和市场需求趋势时非常重要。想想圣诞节如何影响美国的销售，或者中国新年如何影响中国的旅行模式。

这就结束了技巧和窍门的列表。这绝对不是完整的；你只需将其视为一个起点。预测是一个丰富且有趣的领域，有很多注意事项。然而，考虑到这些事项将使你能够产生准确、可靠的预测，并避免许多新手数据科学家犯的错误。

无论如何，请记住预测本身就是一门艺术，与其他类型的机器学习问题不同，要以这种方式来对待它。最后，你将了解 AutoML 用于预测的算法。

理解 AutoML 预测算法

AutoML 预测算法几乎与 AutoML 回归算法相同。预测使用与回归相同的所有树、标准回归、梯度提升和最近邻算法，并且也使用随机梯度下降。有关参考，请参阅第四章，构建 AutoML 回归解决方案。

除了这些算法之外，还有三个特定的预测算法：Auto-ARIMA、Prophet 和 ForecastTCN。你已经在本章前面学习了某些关键差异，这些差异使 ARIMA 和 Prophet 与其他算法不同。ForecastTCN 是一种时间卷积网络，一种神经网络类型。

Auto-ARIMA（自回归积分移动平均）使用目标列的移动平均进行预测。与标准 ARIMA 不同，Auto-ARIMA 优化 ARIMA 参数以创建最佳模型。它在只有关于目标列的可靠信息的单变量时间序列中表现极好。

Prophet与 Auto-ARIMA 类似，它专门用于单变量时间序列。此外，当你的数据具有强烈的季节性模式时，它表现得非常好。与许多预测算法不同，Prophet 对异常值和你的数据集中的剧烈波动具有鲁棒性。与 Auto-ARIMA 一样，你应该在预测项目的开始阶段始终使用 Prophet 来建立基线模型。

在你的 AutoML 预测参数中将enable_dnn设置为True。这个算法非常适合最复杂的预测任务，因为它可以捕捉到数据中的极其复杂的非线性趋势。深度学习是一个复杂的话题，即使在一个章节中也很难解释清楚，因此它超出了本书的范围。ForecastTCN，像其他深度学习模型一样，在训练时使用大量数据时表现最佳。

在图 6.5中提供了这 13 种算法的摘要：

图 6.5 – AutoML 预测算法

与回归一样，AutoML 在每个 AutoML 训练运行结束时执行模型集成。投票集成会对你的预测模型进行加权平均，并使用该结果进行预测。相比之下，堆叠集成使用其他模型的输出训练弹性网络模型。在使用堆叠集成进行预测时存在过拟合的风险；因此，建议将其关闭。

有关这些模型的更多信息，请参阅位于docs.microsoft.com/en-us/azure/machine-learning/how-to-configure-auto-train#configure-your-experiment-settings的 AutoML 文档。

摘要

现在，你已经成功训练了所有三种类型的 AutoML 模型 – 分类、回归和预测。你不仅可以训练一个简单的预测模型，而且你还知道如何使用各种预测参数改进模型，以及如何使用 ARIMA 和 Prophet 构建高性能的基线模型。

此外，你已经获得了大量关于预测与其他问题有何不同以及如何避免常见陷阱的知识。通过明智地利用预测范围功能，你可以预测未来几天、几个月或几年，现在是时候向你的工具箱中添加一个强大的工具了。

在第七章《使用多模型解决方案加速器》中，您将能够为每个时间序列粒度构建单独的模型。您不必构建一个预测模型，而是一次性构建数千个模型，并像对待一个模型一样对它们进行评分。您会发现这种方法可以极大地提高模型的表现，而这只有云原生技术才能实现。

第七章：使用多个模型解决方案加速器

现在你已经体验了使用 AutoML 构建回归、分类和预测模型，现在是时候学习如何在实际业务场景中部署和利用这些模型了。然而，在着手之前，我们首先将向你介绍一个全新的、非常强大的解决方案，那就是多个模型解决方案加速器（MMSA）。

MMSA 让你能够一次性构建数百到数千个机器学习（ML）模型，并且可以轻松扩展到数十万个模型。它是机器学习前沿的先进技术。你不仅可以构建数十万个模型，还可以使用 MMSA 轻松地将它们部署到生产环境中。

在本章中，你将首先安装加速器，并了解它适用的各种用例。然后，你将逐个笔记本地运行加速器的三个部分：准备数据、训练模型和预测新数据。

在每个部分中，你将使用加速器内找到的样本数据以及你用 Python 代码生成的样本数据。这将为你提供使用 MMSA 与文件和表格数据集的示例。最后，你将了解如何使用加速器来最大化性能的技巧和窍门，你还将被介绍到分层预测等概念。

到本章结束时，你将掌握使用 AutoML 的 MMSA。你将能够将你的数据带入 MMSA，使其处于正确的形状，并训练数千个模型。这个解决方案非常适合你希望在大量产品或商店上训练类似模型的情况，例如，为每种产品和商店的组合构建一个单独的预测模型。全美的大型公司都在使用它，到本章结束时，你也将能够使用它。

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

安装多个模型解决方案加速器
为多个模型准备数据
同时训练多个模型
为多个模型评分新数据
提高你的多个模型结果

技术要求

在本章中，你将登录到你的Azure 机器学习工作室（AMLS），在一个计算实例上打开一个 Jupyter 笔记本，并从 GitHub 上的位置安装 MMSA。然后，你将依次运行 MMSA 的三个部分，准备数据、远程训练模型和预测数据。因此，你需要一个 Azure 账户、一个用于编写 Python 代码的计算实例和一个用于远程训练的计算集群。完整的要求列表如下：

上网权限。
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium。
一个微软 Azure 账户。
你应该已经创建了一个 AMLS 工作区。
你应该在第二章“Azure 机器学习服务入门”中创建了一个计算实例。
您应该在第二章“Azure 机器学习服务入门”中创建了计算集群。
您应该了解如何从 AMLS 计算实例导航到 Jupyter 环境，如第四章“构建 AutoML 回归解决方案”中所示。

本章的代码在此处可用：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/tree/master/Chapter07。

安装许多模型解决方案加速器

MMSA 是由微软在 2019 年构建的，旨在满足越来越多的客户需求，他们希望同时训练数十万个类似的机器学习模型。这对于产品需求预测尤为重要，因为您试图在许多不同地点对许多不同的产品进行预测。

加速器的动力是模型精度。虽然您可以训练一个模型来预测所有产品线以及所有商店的产品需求，但您会发现为每个产品和商店的组合训练单独的模型往往会产生更好的性能。这是因为许多因素都取决于您的算法和数据。当您处理分布在全球各地的数十万个不同产品时，某些算法可能很难找到有意义的模式。

此外，相同的列可能与您试图预测的目标列有不同的甚至相反的关系。想象一下天气和产品销售。当外面下雪时，某些产品，如冬季帽子、手套或靴子，很可能会出现销售激增。而其他产品，如冰淇淋，很可能会出现销售下降。虽然一些算法可以处理产品线之间的这些相反关系，但许多算法不能，并且使用 MMSA 为每个产品构建单独的模型通常会产生更好的指标。

除了预测 MMSA 的产品需求之外，其他常见用例还包括在工厂车间数千台设备和机器上的预测性维护、数百个商店的人力资源优化模型、美国各州的文本分析用例和法律文件搜索模型，以及许多其他类似场景。尽管如此，预测仍然是最常见的用例。连锁店尤其发现 MMSA 很有吸引力。

从技术角度讲，决定是否使用 MMSA 的关键因素是您的数据中是否存在一个或多个列，您可以使用这些列将数据分割成多个文件。例如，商店、产品和地区等列是分割的理想目标。如果您的数据中不存在这样的列，就没有必要使用 MMSA。

同样，如果你预期你的数据中的模式在产品、分组和地区等列中相对稳定，你应该像处理任何其他问题一样，使用 AutoML 训练一个单独的 ML 模型。

在本节中，你将在你的 Jupyter 环境中安装 MMSA。首先，你将创建一个仅用于安装的新 Jupyter 笔记本。然后，你将在你的 Jupyter 环境中安装 MMSA。这将创建一系列文件和文件夹。最后，你将能够确认 MMSA 已成功安装，并识别你将在本章剩余部分使用的笔记本。

在你的 Jupyter 环境中创建一个新的笔记本

执行以下步骤在你的计算实例上创建一个新的 Jupyter 笔记本：

首先，通过导航到 ml.azure.com 打开你的 AML 工作室实例。
点击 Compute，启动一个计算实例，并打开一个 Jupyter 环境。
创建一个新的 Jupyter 笔记本，并将其命名为 Accelerator_Installation。如果你需要复习，请查看 第四章，构建 AutoML 回归解决方案。

在创建好笔记本后，你现在可以安装来自 GitHub 的加速器。

从 GitHub 安装 MMSA

MMSA 是由微软开发的一个公开可用的解决方案，托管在 GitHub 仓库上。使用以下代码在你的 Jupyter 环境中安装 MMSA：

使用以下代码将 MMSA 仓库克隆到你的 Jupyter 笔记本文件系统中：
```
!git clone https://github.com/microsoft/solution-accelerator-many-models
```
所有文件现在都已加载到一个名为 solution-accelerator-many-models 的新文件夹中。点击屏幕顶部的 Jupyter 图标以导航到你的文件目录，如图 图 7.1 所示：

图 7.1 – 导航到你的文件目录
通过点击打开 solution-accelerator-many-models 文件夹。
打开文件夹后，你会看到许多文件和文件夹。在 为多个模型准备数据 部分你将使用的第一个文件是 01_Data_Preparation.ipynb。如果你希望为 MMSA 设置一个新的计算集群，你应该首先运行 00_Setup_AML_Workspace.ipynb。注意这些信息。
接下来，打开 Automated_ML 文件夹。这个文件夹包含两个子文件夹，分别称为 02_AutoML_Training_Pipeline 和 03_AutoML_Forecasting_Pipeline。
打开每个 AutoML 管道。每个管道都包含一个与文件夹同名的 Jupyter 笔记本。注意这些信息。

在本章的剩余部分，你将只与这三个 Jupyter 笔记本交互，即01_Data_Preparation.ipynb、02_AutoML_Training_Pipeline和03_AutoML_Forecasting_Pipeline。在每种情况下，首先以默认样本数据集的方式运行笔记本。然后，你将创建另一个笔记本并使用类似的代码训练不同的数据集。这将教会你如何使用 MMSA 处理文件和表格数据集，以及如何处理你自己的数据。你将从准备数据开始。

为许多模型准备数据

虽然同时训练成千上万的机器学习模型听起来很复杂，但 MMSA（多模型学习算法）使其变得简单。笔记本中包含的示例使用了你在第六章“构建 AutoML 预测解决方案”中使用的OJ Sales数据。你只需打开并运行01_Data_Preparation.ipynb即可准备数据。通过仔细阅读说明并逐步在笔记本中缓慢工作，你将能够理解每个部分的内容。

一旦你能够理解每个部分的作用并且已经加载了OJ Sales数据，你将能够将新的数据集加载到你的 Jupyter 笔记本中。这样，在本节结束时，你将能够将你的数据加载到 Azure 中，为 MMSA 修改它，并掌握使用这个强大解决方案的能力。

准备样本 OJ 数据集

要了解第一个笔记本是如何工作的，请按照以下顺序遵循这些说明：

打开01_Data_Preparation.ipynb。
运行笔记本中1.0部分的全部单元格。这些单元格在你的文件目录中创建一个名为oj_sales_data的文件夹，并将OJ Sales数据下载到那里。运行1.0部分后，检查你新文件夹中的文件；oj_sales_data将位于01_Data_Preparation.ipynb相同的目录级别。
运行笔记本中2.0部分的单个单元格。这个单元格根据日期将数据分割成训练数据和推理数据。它在oj_sales_data文件夹中创建两个文件夹，一个名为upload_train_data，另一个名为upload_inference_data。运行单元格后，查看每个文件夹的内容。你应该会看到名为Store1000_dominicks.csv等文件的文件。点击其中一个文件，查看数据的样子。
运行笔记本中3.0部分的全部单元格。这些单元格将你的计算实例上的文件目录中的数据复制到你的数据存储的文件目录中。这将复制文件结构，你最终会在你的数据存储上得到oj_sales_data文件夹以及upload_train_data和upload_inference_data子文件夹。如果你愿意，打开你的 Azure 存储账户并尝试定位这些文件夹。记住，它们将位于以azureml-blobstore开头的容器中。
运行笔记本中4.0节的单个单元格。此单元格创建两个文件数据集，一个名为oj_data_small_train，另一个名为oj_data_small_inference。这些是您将在02_AutoML_Training_Pipeline和03_AutoML_Forecasting_Pipeline中使用的数据集。
运行笔记本中5.0节的所有单元格以查看您的数据。

重要提示

如果您直接运行笔记本，您将使用 10 个文件训练少量模型。您可以将dataset_maxfiles设置为11793，在笔记本的1.0节中训练更多的模型。在这种情况下，您的数据集将被称为oj_data_inference和oj_data_train。

您现在已准备好OJ Sales数据以供加速器使用。为了将您自己的数据带入加速器，您需要遵循一些重要的注意事项。最重要的是，OJ Sales数据是预先按商店和橙汁品牌分割的。您需要使用自己的数据在一个新的 Jupyter 笔记本中模仿这种结构。

准备 pandas 数据框

将自己的数据带入 MMSA 的过程并不明确。毕竟，OJ Sales是一个由 11,793 个文件组成的文件数据集。您更有可能使用单个文件或来自数据库中单个表的数据。此外，您最有可能通过 pandas（最常用的 Python 包）来读取它。要学习如何使用 pandas 数据框与 MMSA 一起使用，请执行以下步骤：

从Automated-Machine-Learning-on-Microsoft-Azure GitHub 仓库下载ManyModelsSampleData.csv文件。
导航到您的 Jupyter 环境。
打开solution-accelerator-many-models文件夹。
将ManyModelsSampleData.csv文件拖到您的 Jupyter 环境中。
创建一个新的 Jupyter 笔记本并打开它。将其重命名为01_Data_PreparationMy-Data.ipynb。
要加载所有库，您需要以下代码：
```
import pandas as pd
import numpy as np
import os
import datetime as dt
from azureml.core import Workspace, Dataset, Datastore
from scripts.helper import split_data
```
您应该能从第四章，构建 AutoML 回归解决方案中识别出pandas、numpy、Workspace、Dataset和Datastore。您也在第六章，构建 AutoML 预测解决方案中使用了os。

新增的split_data函数是一个datetime，它允许您将字符串对象转换为正确的 Python 日期时间对象。这是必需的，因为split_data需要日期时间对象才能正常工作。
使用以下代码将ManyModelsSampleData.csv文件读入 pandas 数据框：
```
ManyModelsSample =\
pd.read_csv('ManyModelsSampleData.csv', header = 0)
```
将标题设置为0将使用 CSV 文件的第一行作为列名。

使用以下代码创建一个名为MMSA_Sample_Folder的文件夹：

target_path = 'MMSA_Sample_Folder' 
os.makedirs(target_path, exist_ok=True)

查看您的数据集：
```
ManyModelsSample
```
您会发现这个数据集有三个列：日期、商店和销售额。这是一个非常简单的预测数据集。有四个商店，每个商店都有一个时间序列，从 2020 年 1 月 1 日延伸到 2021 年 3 月 31 日。您希望预测未来的销售额。
使用以下代码将您的日期列转换为datetime对象：
```
ManyModelsSample['Date'] =\
ManyModelsSample['Date'].apply(lambda x:\
dt.datetime.strptime(x, '%m/%d/%Y'))
```
此代码将您的日期列作为字符串，并使用datetime包应用一个函数来将其转换为datetime对象。
使用以下代码将 pandas 数据框分割成四个单独的 CSV 文件，每个商店一个，并将它们放置在 MMSA 样本文件夹中：
```
for x, y in ManyModelsSample.groupby('Store'):
    y.to_csv('MMSA_Sample_Folder/{}.csv'.format(x),\
 header=True, index_label=False)
```
理解x是您的ManyModelsSample数据框中的单个商店，而y是只包含该商店值的 pandas 数据框。此代码遍历所有四个商店，并逐个在MMSA_Sample_Folder内创建带有标题的 CSV 文件。每个文件将是商店的名称。在这种情况下，商店是以它们所在的城市的名称命名的：纽约、华盛顿特区、旧金山和西雅图。

重要提示

您用于分割数据的时间列绝对必须是 datetime 对象，而不是字符串。如果您的时间列保持为字符串，则会导致后续的预测运行失败。
为您的时间列以及训练和评分数据的截止日期设置变量：
```
timestamp_column = 'Date'
split_date = '2021-03-01'
```
MMSA 文档将评分数据称为推理数据。split_date，请记住，您指定的日期及其之后的每个日期将用于评分，而所有早于此日期的日期将用于训练。您的split_date函数必须使用此处使用的格式。
使用以下代码将数据分割为训练和推理文件：
```
train_path, inference_path = split_data(target_path, \
timestamp_column, split_date)
```
此代码使用您的split_data辅助函数。在MMSA_Sample_Folder中，将创建两个新的文件夹，每个文件夹包含四组训练和评分文件。
将您的 Jupyter 笔记本连接到您的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果您被提示登录，请按照说明进行操作。
将您的数据存储设置为与您的 AMLS 工作区一起提供的默认数据存储：
```
datastore = ws.get_default_datastore()
```
此代码与您在第四章中使用的代码略有不同，构建 AutoML 回归解决方案。在 AzureML SDK 中，经常有具有相同用途的函数。
使用以下代码将您的训练数据上传到默认数据存储：
```
ds_train_path = target_path + '_train'
datastore.upload(src_dir=train_path, \
target_path=ds_train_path, overwrite=True)
```
此代码将您的训练文件写入默认数据存储中名为MMSA_Sample_Folder_train的文件夹。
使用以下代码将您的评分数据上传到默认数据存储：
```
ds_inference_path = target_path + '_inference'
datastore.upload(src_dir=inference_path, \
target_path=ds_inference_path, overwrite=True)
```
此代码将您的训练文件写入默认数据存储中名为MMSA_Sample_Folder_inference的文件夹。
使用以下代码为您的训练和评分数据创建文件数据集：
```
ds_train = \
Dataset.File.from_files(path=\
datastore.path(ds_train_path), validate=False)
ds_inference = Dataset.File.from_files(path=\
datastore.path(ds_inference_path), validate=False)
```
MMSA 需要文件数据集才能工作。因此，您需要将默认数据存储上的文件夹注册为文件数据集。这将注册整个文件夹及其所有内容。
为注册数据集时使用的名称创建变量：
```
dataset_name = 'MMSA_Sample'
train_dataset_name = dataset_name + '_train'
inference_dataset_name = dataset_name + '_inference'
```
使用此代码将确保您使用名称MMSA_Sample_train和MMSA_Sample_inference注册您的数据集。
使用以下代码注册您的文件数据集：
```
ds_train.register(ws, train_dataset_name, create_new_version=True)
ds_inference.register(ws, inference_dataset_name, create_new_version=True)
```
你现在应该在 AML 工作室中有两个额外的数据集。通过点击左侧面板上的数据集来检查。

确保保存你的笔记本，因为这段代码将来在你希望使用 MMSA 处理自己的数据时非常有用。你现在已经准备好了OJ Sales数据以及简单的样本数据，并将它们作为单独的训练和评分文件数据集保存。这是使用加速器的第一步。现在你已经准备好了数据，是时候训练大量模型了。

同时训练多个模型

就像为多个模型准备数据一样，训练多个模型只是简单地导航到正确的笔记本并运行单元格。不需要自定义代码，你只需要更改一些设置。

就像准备数据一样，你首先需要逐步运行笔记本，以仔细了解其工作原理。一旦你有了这种理解，你将创建一个新的笔记本，其中包含使用从样本数据创建的集合的代码。这将极大地帮助你，因为你将确切地知道需要更改代码的哪些部分以促进你自己的项目。

训练样本 OJ 数据集

要使用 OJ 数据训练多个模型并了解底层过程，请按以下步骤操作：

从solution-accelerator-many-models文件夹中，点击Automated_ML文件夹。
从Automated_ML文件夹中，点击02_AutoML_Training_Pipeline文件夹。
打开02_AutoML_Training_Pipeline.ipynb。
运行section 1.0中的所有单元格。这会设置你的数据存储和你的工作区，并且给你的多个模型实验分配一个名称。请注意，这段代码还会输出一个漂亮的表格，列出你的 AMLS 工作区详情以及你的数据存储名称。如果你愿意，可以将此表格添加到所有代码中，或者你可以使用本书中的模板来采用更直接、简洁的编码方法。

提示

如果你遇到加载任何 Azure 库的问题，请通过运行以下链接中找到的Update AzureML SDK.ipynb笔记本来更新 Azure MLSDK：https://github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Update-AzureML-SDK.ipynb。
运行section 2.0中的单个单元格。这将检索你的训练数据集，oj_data_small_train。请注意，数据集在这里被设置两次，首先作为典型数据集，然后作为命名输入。命名输入是某些 ML 管道用于处理数据集的 Azure 工具。MMSA 的底层是一个并行运行 ML 管道。这个 ML 管道允许你并行运行不同类型的作业。

重要提示

MMSA 经常使用AzureML 贡献者包。这些包处于开发中。你可能需要取消注释单元格并安装本节中的包，具体取决于你的 AzureML SDK 版本。你需要安装的所有包都会在代码中列出。
运行 section 3.0 中的所有单元格。这些单元格创建一个计算集群以训练所有模型，设置您的 AutoML 预测设置，并设置您的多个模型 Store 和 Brand。如果您的 Azure 订阅无法使用 STANDARD_D16S_V3 STANDARD_DS3_V2。

重要提示

您的并行运行设置的 节点计数 应设置为您的计算集群中的节点数。您的 每个节点的进程计数 不应超过每个节点上的核心数。例如，如果您使用的是 Standard_DS3_v2 VM，则每个节点的进程计数不应超过 4。
运行 section 4.0 中的两个单元格。这些单元格训练了您的所有模型。
运行 section 6.0 中的单元格以获取您的 AutoML 运行列表及其注册的标签。这样您可以跟踪所有已注册的不同模型。MMSA 会自动为您分区列生成标签。
通过取消注释第一个单元格并运行它来发布您的多个模型训练管道。不要运行第二个单元格，因为这会将您的管道安排为自动按计划运行。尽管这个功能在生产环境中很有用，但它确实会增加成本。

在 15 到 30 分钟内，您应该已经训练并注册了所有 10 个模型。与正常的 AutoML 运行不同，MMSA 会自动为每个分组（在本例中为橙汁品牌和商店）训练的最佳模型进行注册。这个功能扩展得非常好，一些微软客户正在使用它来持续训练和重新训练数十万个模型。

您可以通过点击蓝色链接来检查门户中的运行，这将带您到以下截图所示的管道可视化：

图 7.2 – MMSA 在行动

接下来，您将创建一个新的笔记本，并使用您加载的样本数据（作为 pandas 数据框）训练许多模型。您将大大简化第二个笔记本中的代码以实现相同的结果。这将帮助您在未来轻松地将 MMSA 应用于您自己的问题。

使用 MMSA 训练您的样本数据集

正如您修改了第一个笔记本一样，您需要修改第二个笔记本以使用您自己的代码。所有步骤都将相同，但代码将更加简洁且易于阅读。以下是一些步骤：

打开 solution-accelerator-many-models 文件夹。
打开 Automated_ML 文件夹。
打开 02_AutoML_Training_Pipeline 文件夹。
创建一个新的 Jupyter 笔记本并打开它。将其重命名为 02_AutoML_Training_Pipeline-My-Data.ipynb。
使用以下代码加载您将需要的所有熟悉库：
```
from azureml.core import Workspace, Datastore, Dataset
from azureml.core import Experiment
from azureml.core.compute import ComputeTarget
import pandas as pd
import os
```
您应该熟悉大多数这些包来自 为多个模型准备数据 部分。ComputeTarget 用于设置用于远程训练的计算集群，并在 第四章，构建 AutoML 回归解决方案 中进行了介绍。
使用以下代码加载您将需要用于训练 MMSA 解决方案的新库：
```
from azureml.contrib.automl.pipeline.steps import AutoMLPipelineBuilder
from azureml.pipeline.core import Pipeline
from scripts.helper import get_training_output
import logging
```
AzureMLPipelineBuilder 允许您构建多个模型训练运行，并且是一个贡献包。如果您还没有使用原始 MMSA 训练笔记本中注释掉的代码来安装它，请确保使用 pip 在此处安装它。Pipeline 允许您构建机器学习管道，这对于在底层运行 MMSA 是必要的。

最后，get_training_output 是另一个辅助函数，允许您检索有关您训练的模型的信息，而 logging 允许收集有关训练运行的更详细日志。
将您的 Jupyter 笔记本连接到您的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果您被提示登录，请按照说明进行操作。
将您的数据存储设置为与您的 AMLS 工作区一起提供的默认数据存储：
```
dstore = ws.get_default_datastore()
```
请注意，数据存储变量名与其他 Jupyter 笔记本不同。

使用以下代码设置您的实验并为其命名：

experiment = Experiment(ws, 'manymodels-training-pipeline-pandas-data')

使用以下代码指定您的训练数据集：
```
filedst_10_models = Dataset.get_by_name(ws, name = 'MMSA_Sample_train')
filedst_10_models_input =\
filedst_10_models.as_named_input('MMSA_Sample_train')
```
您给您的命名输入起什么名字无关紧要。重要的是底层数据集。MMSA 将找到正确的数据集。
使用以下代码设置您的计算集群，该集群将用于远程训练：
```
compute = "compute-cluster"
```
如果您为多个模型训练创建了一个不同的计算集群，请使用该集群。
设置您的分区列名称：
```
partition_column_names = ['Store']  
```
您可以根据您的业务问题需要设置尽可能多的分区列。OJ Sales 有两个。样本数据有一个。

根据需要调整您的 AutoML 设置。具体来说，将 label_column_name 设置为 Sales。这是您试图预测的列。将 debug_log 的名称更改为与 OJ Sales 的训练运行区分开来。将 time_column_name 设置为 Date。将 grain_column_names 设置为 Store。

关于 MMSA 的一项令人困惑的事情是，您还应该将您的分区列传递给 grain_column_names。有关这些设置的更多信息，请参阅第六章，构建 AutoML 预测解决方案：

automl_settings = {
    "task" : 'forecasting',
    "primary_metric" : \
    'normalized_root_mean_squared_error',
    "iteration_timeout_minutes" : 10, 
    "iterations" : 15,
    "experiment_timeout_hours" : 1,
    "label_column_name" : 'Sales',
    "n_cross_validations" : 3,
    "verbosity" : logging.INFO, 
    "debug_log": 'automl_pandas_debug.txt',
    "time_column_name": 'Date',
    "max_horizon" : 31,
    "track_child_runs": False,
    "partition_column_names": partition_column_names,
    "grain_column_names": ['Store'],
    "pipeline_fetch_max_batch_size": 15
}

重要提示

MMSA 也可以用于 AutoML 问题的回归和分类。在这种情况下，请确保传递针对每种问题类型特定的相关设置。

通过以下代码传递您的 MMSA 配置。确保您调整 node_count 和 process_count_per_node 以匹配您的计算集群上的节点数和单个虚拟机上的核心数。

train_steps =\
AutoMLPipelineBuilder.get_many_models_train_steps(
experiment=experiment,
                   automl_settings=automl_settings,
                   train_data=filedst_10_models_input,
                   compute_target=compute,
                   partition_column_names=\
                   partition_column_names,
                   node_count=4,
                   process_count_per_node=4,
                   run_invocation_timeout=3700,
                   output_datastore=dstore)

使用以下代码提交您的 MMSA 训练运行：

pipeline = Pipeline(workspace=ws, steps=train_steps)
run = experiment.submit(pipeline)

使用以下代码获取有关您的 MMSA 训练运行的附加详细信息：
```
run.wait_for_completion(show_output=True) 
```
使用以下代码发布您的 MMSA 管道：
```
published_pipeline = pipeline.publish(name = \
'MMSA_pandas', description = 'MMSA Solution using a pandas dataframe', \
version = '1', continue_on_step_failure = False)
```
此代码将发布您的管道，以便您可以在方便的时候安排它。将 continue_on_step_failure 设置为 False 将防止此代码发布出错的管道。
如果你愿意，你可以从原始的 MMSA 训练笔记本中复制代码来安排 MMSA 管道按节奏运行。你还可以复制代码来查看整体运行的成果；这对于调试错误非常有用。

你现在已经成功使用OJ Sales数据和作为 pandas dataframe 读取的样本文件训练了多个模型。除了从头开始修改 MMSA 代码外，你还有一个简化的笔记本在手，你可以轻松地使用它来构建自己的解决方案。接下来，你将学习如何使用加速器训练的模型评分新数据。这将完成你对 MMSA 使用 AutoML 的介绍。

为多个模型评分新数据

使用 MMSA 评分新数据是一项相对直接的任务。一旦你的模型训练完成，只需导航到正确的笔记本，将你的变量更改为与你的训练笔记本匹配，然后点击运行按钮。由于与训练笔记本相比，可更改的设置很少，因此使用自己的代码使用起来甚至更简单。

在本节中，与其他部分一样，首先你将运行带有OJ Sales的现成评分笔记本。然后，你将创建一个新的笔记本来评分样本数据。

使用 MMSA 评分 OJ 销售数据

要使用你训练的多个模型评分OJ Sales数据，请按照以下步骤操作：

从solution-accelerator-many-models文件夹中，打开Automated_ML文件夹。
从Automated_ML文件夹中，打开03_AutoML_Forecasting_Pipeline文件夹。
打开03_AutoML_Forecasting_Pipeline.ipynb。
运行section 1.0中的所有单元格。这些单元格设置你的 AMLS 工作区、计算集群、数据存储和实验。与之前的训练笔记本一样，预测笔记本也是一个机器学习管道。有关你的机器学习管道运行的信息，如你的训练运行，都保存在实验工件中。

小贴士

你运行以训练多个模型的训练实验与你现在运行的推理实验不同。请确保它们有不同的名称。
运行section 2.0中的单个单元格。此单元格调用使用数据准备笔记本创建的推理数据集；这是你将使用训练模型评分的数据。
在section 3.0中，设置你之前运行的02_AutoML_Training_Pipeline.ipynb训练笔记本或在 AMLS 的实验部分。你的管道运行 ID 是训练所有模型实验的 ID：
```
training_pipeline_run_id ="your pipeline run id"
training_experiment_name = "your training experiment name" 
```
运行section 3.0中的第二个单元格。此单元格配置了你的多个模型评分管道的设置。最重要的是，这里传递了你的分区列、你试图预测的目标列以及时间列，这些列决定了你预测的节奏。
运行section 4.0中的两个单元格以评分新数据。这是一个机器学习管道运行，你的计算集群需要一些时间来启动。然而，一旦启动并开始机器学习管道，评分你的数据将会非常快。
运行5.0部分的单个单元格以查看您的结果，如图所示：

图 7.3 – MMSA 结果
如果您想发布您的机器学习管道以供以后使用，请运行6.0部分的第一个单元格。请避免运行第二个单元格，因为这会为您的管道创建一个自动化的时间表，这可能会随着时间的推移变得相当昂贵。

您现在已经从开始到结束完成了 MMSA OJ Sales笔记本。您已经准备数据并将其塑造成正确的格式，将其分割成多个文件。然后，您并行训练了 10 个模型，并使用这些模型对数据进行评分。

是时候用简化的笔记本对您的样本数据集进行评分并查看输出了。请记住，输出不应该特别出色，因为销售数字是随机生成的。然而，这将为您提供一个使用自己的数据生成结果的模板。

使用多个模型对样本数据集进行评分

为了对您的样本数据集中的数据进行评分，请遵循以下说明：

打开solution-accelerator-many-models文件夹。
打开Automated_ML文件夹。
打开03_AutoML_Forecasting_Pipeline文件夹。
创建一个新的 Jupyter 笔记本并打开它。将其重命名为03_AutoML_Forecasting_Pipeline-My-Data.ipynb。

使用以下代码加载本章中已经使用过的所有库：

from azureml.core import Workspace, Datastore, Dataset
from azureml.core import Experiment
import pandas as pd
import os
from azureml.core.compute import ComputeTarget
from azureml.contrib.automl.pipeline.steps import AutoMLPipelineBuilder
from azureml.pipeline.core import Pipeline

如果您需要任何这些内容的复习，请参阅同时训练多个模型部分。

使用以下代码加载本节中引入的所有库：
```
import shutil
import sys 
from scripts.helper import get_forecasting_output
```
您还有一个辅助函数get_forecasting_output。这个函数让您可以轻松检索 MMSA 生成的预测，而无需任何麻烦。get_forecasting_output使用了sys和shutil。虽然shutil让您可以像os一样操作文件和文件夹，但sys让您可以与 Python 运行时环境进行交互。
将您的 Jupyter 笔记本连接到您的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果您被提示登录，请按照说明进行操作。
将您的数据存储设置为与您的 AMLS 工作区一起提供的默认数据存储：
```
dstore = ws.get_default_datastore()
```
这使用与训练笔记本相同的存储变量名。

使用以下代码设置您的实验并给它命名：

experiment = Experiment(ws, 'manymodels-forecasting-pipeline-pandas-data')

使用以下代码指定您的训练数据集：
```
filedst_10_models = Dataset.get_by_name(ws, name = 'MMSA_Sample_inference')
filedst_10_models_input =\
filedst_10_models.as_named_input('MMSA_Sample_inference')
```
您给命名输入起什么名字都无关紧要。重要的是底层的数据集。MMSA 将找到正确的数据集。
使用以下代码设置您的计算集群，该集群将用于远程训练：
```
compute = "compute-cluster"
```
从您用于训练模型的机器学习管道中检索您的实验名称和运行 ID。您可以在 AML 工作室的实验下找到运行 ID：
```
training_experiment_name = "manymodels-training-pipeline-pandas-data"
training_pipeline_run_id ="your-run-ID"
```
设置您的分区列名称：
```
partition_column_names = ['Store']
```

传递您的 MMSA 配置。确保您将 time_column_name 设置为 Date，将您试图预测的目标列设置为 Sales，将 node_count 设置为您计算集群上的最大节点数，并将 process_count_per_node 设置为单个 VM 上的核心数，如下面的代码所示：

inference_steps =\
AutoMLPipelineBuilder.get_many_models_batch_inference_steps(\
                    experiment=experiment,
                    inference_data=\
                    filedst_10_models_input,
                    compute_target=compute,
                    node_count=4,
                    process_count_per_node=4,
                    run_invocation_timeout=300,
                    train_experiment_name=\
                    training_experiment_name,
                    train_run_id=\
                    training_pipeline_run_id,
                    partition_column_names=\
                    partition_column_names,
                    time_column_name="Date",
                    target_column_name="Sales")

使用以下代码提交您的 MMSA 评分运行：

pipeline = Pipeline(workspace=ws, steps=train_steps)
run = experiment.submit(pipeline)

使用以下代码获取有关您的 MMSA 评分运行的更多详细信息：
```
run.wait_for_completion(show_output=True) 
```
这应该只需要几分钟就能运行完成。

一旦您的 ML 管道完成，使用以下代码发布您的 ML 管道：

published_pipeline = pipeline.publish(name = 'automl_score_many_models_pandas',
                   description = \
                  'MMSA Solution using x data',
                   version = '1',
                   continue_on_step_failure = False)

发布您的评分管道将让您在未来非常容易地再次运行它。您将在 第九章，“实现批量评分解决方案”中了解更多关于 ML 管道的信息。

使用以下代码查看您结果的前 10 行：

forecasting_results_name = "forecasting_results"
forecasting_output_name =\
"many_models_inference_output"
forecast_file = get_forecasting_output(run,\
forecasting_results_name, forecasting_output_name)
df = pd.read_csv(forecast_file, delimiter=" ",\
header=None)
df.columns = ["Date", "Store", "Sales", "Predicted" ]
df.head(10)

要使此代码正常工作，您需要手动输入数据集的列名。最后一列将始终是您的解决方案生成的预测。您的结果应类似于以下截图。由于数据是随机的，所以它可能不会很好：

图 7.4 – 样本数据上的多个模型结果

成功！您已经达到了使用作为 pandas dataframe 读取的样本数据创建完整 MMSA 解决方案的最高目标。现在您处于最佳位置，可以使用自己的数据使用此解决方案。

第一次仅使用“OJ 销售数据”运行 MMSA 时，它似乎非常简单，没有什么难度。尽管很简单，但您会发现它产生的结果比您在 第六章，“构建预测解决方案”中训练的单个模型要好得多。通过简单地按正确顺序运行几个笔记本，您就能创建一个高性能的模型。

经验已经教会您如何调整 MMSA 以与您自己的数据一起工作，而且这也很简单。然而，第一次您尝试将您自己的数据应用到它上面时，您可能会发现它有点棘手。将您的数据格式化到正确的格式可能会令人沮丧。为了帮助使您的体验顺利，本章的最后部分涵盖了提高您解决方案的技巧和窍门。

提高多个模型的结果

现在您已经将所有三个笔记本调整到运行您自己的代码，您应该对自己的使用 MMSA 的能力感到相当自信。尽管如此，很容易陷入困境。多个模型是一个复杂的框架，您数据中的小错误可能导致错误。

此外，有时在处理成千上万的您希望训练的文件时，很难知道您的数据将是什么样子。以下是一些好的建议，以确保您在使用 MMSA 与您自己的数据时不会陷入僵局：

在使用加速器之前，始终先尝试使用整个数据集创建一个单独的模型。检查你模型的性能。只有当单个模型的性能低于你的期望或在需要获得最佳准确率对项目至关重要的情形下，才使用 MMSA。有时，复杂性和性能之间的权衡并不值得。
在使用加速器之前，花大量时间确保你的数据被正确分割。每个分区列的组合都需要有自己的文件。仔细考虑你希望用作分区的列。或者，尝试几种不同的组合，看看哪种组合能提供最佳性能。
当使用日期列分割数据以进行预测时，务必确保它是以日期时间格式而不是字符串格式。通常，数据科学家会犯在字符串列上分割数据的错误。有时当这种情况发生时，前两个笔记本可以正常运行，并且你可以训练模型。然而，当你到达第三个笔记本进行数据预测时，你会遇到错误并不得不从头开始。
在数据准备笔记本中，不要硬编码split_date。相反，让它根据当前日期时间、你期望的训练数据量以及你想要预测的小时数、天数、周数或月数来变化。这样，当你重新训练 MMSA 解决方案时，你会得到适当时间段的预测。记住，这仅适用于预测问题。
对于所有问题，在将数据传递到解决方案之前，仔细研究你的数据。虽然 AutoML 可以处理空值和许多其他错误，但它对其他问题（如预测问题时间列中的大缺口）的处理较少。在将数据传递到 MMSA 之前，尽可能多地清理你的数据。
虽然 MMSA 笔记本是使用预测示例创建的，但它很容易适应回归和分类问题。由于这些问题的本质比预测简单，因此为这些问题导入自己的代码相对容易。你不必担心日期。
熟悉日志文件。当你导航它们时，请确保首先点击失败的管道步骤。然后，点击logs并展开它。然后，寻找一个名为user的文件夹。在user文件夹中，你需要搜索名为error的文件夹。error文件夹包含一系列由点号分隔的数字文件夹，例如10.0.0.5。

这些文件夹包含调试目的最重要的文件。每个文件都以process开头并以.txt结尾。打开这些文件并使用它们来查找代码中的任何错误。
在使用 MMSA 训练模型时，不要害怕使用非常大的计算集群。虽然更大的虚拟机每小时的使用成本更高，但它们的训练速度也比便宜的虚拟机快得多。
请记住，当你使用 MMSA 训练模型时，运行它的计算集群将根据你训练的模型数量，在相对较长时间内达到最大容量。因此，确保你用于训练多个模型的计算集群不负责同时运行其他工作是有意义的。
MMSA 解决的关键问题是，当你拥有多个高维度的分类列时，许多传统的机器学习算法由于数学原因表现不佳。随着你的业务扩张，你的产品、地点和劳动力都在扩张，MMSA 对你的业务变得越来越合适。
定期重新训练你的模型。监控数十万个机器学习模型以确定哪些需要重新训练是非常困难的。相反，每周或每月重新训练所有模型以确保高性能。

尽管你已经收到了许多有助于使用 MMSA 构建解决方案的技巧和窍门，但最好的建议就是尽可能多地练习。尽可能多地探索解决方案，并尽可能多地发现潜在的问题。

无论如何，请记住，MMSA 和 AutoML 在你传入干净数据时表现最佳。本节总结了本章内容。你现在拥有了实施真正颠覆性解决方案在自动化机器学习领域的专业知识、知识和实践。

摘要

类似于 MMSA 的高级解决方案处于机器学习和人工智能的前沿。这是一项真正处于技术前沿的技术，现在它又成了你手中的另一件工具。

你不仅运行了 OJ Sales 数据上的所有三个笔记本，还将代码转换为可以接受其他数据集并理解其工作原理。使用 MMSA 准备数据、训练模型和预测未来都是你已经做过的事情，也可以再次做。你可能已经有一个可以应用它的用例，或者你可能需要再等几年，直到你的公司准备好，但你已经准备好了。

第八章，选择实时评分与批量评分，继续你在机器学习世界前沿的旅程。一旦你在 AutoML 中构建了一个模型，下一步就是部署它，有两种选择：批量评分与实时评分。你将学习何时使用批量评分，何时使用实时评分，以及两者之间的主要区别。掌握这些概念对于成功将你的 AutoML 模型应用于现实世界的商业场景至关重要。

第三部分：生产中的 AutoML – 自动化实时和批量评分解决方案

第三部分将训练你将之前训练的模型投入生产。你将学习如何以端到端的方式自动化机器学习解决方案。

本节包含以下章节：

第八章, 选择实时评分与批量评分
第九章, 实现批量评分解决方案
第十章, 创建端到端 AutoML 解决方案
第十一章, 实现实时评分解决方案
第十二章, 利用 AutoML 实现商业价值

第八章：选择实时评分与批量评分

如你在前几章中体验到的，训练 AutoML 模型简单直接。无论你选择使用Azure 机器学习工作室（AMLS）GUI来训练模型，还是在 Python 中使用 Jupyter 编写 AutoML 解决方案的代码，你都可以在几分钟内构建高度准确的机器学习（ML）模型。然而，你仍然需要学习如何部署它们。在 Azure 中，你可以将之前训练好的机器学习模型以实时和批量两种方式部署到新数据的评分中。

在本章中，你将首先学习什么是批量评分解决方案，何时使用它，以及何时重新训练批量模型是有意义的。接着，你将学习什么是实时评分解决方案，何时使用它，以及何时重新训练实时模型是有意义的。最后，你将通过阅读各种不同的场景，确定应该使用哪种类型的评分。所有场景都是基于真实公司面临的常见问题。

到你完成本章时，你将获得一项宝贵的技能：能够识别何时应该构建批量评分解决方案，何时应该构建实时解决方案。

批量评分场景需要你构建机器学习（ML）管道，你将在第九章**，实现批量评分解决方案中学习到这方面的内容。另一方面，实时评分场景需要你在Azure Kubernetes 服务（AKS）上构建实时评分端点，这将在第十一章**，实现实时评分解决方案中介绍。很多时候，组织错误地实施了错误类型的解决方案，但你将能够避免这种陷阱。

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

架构批量评分解决方案
架构实时评分解决方案
确定批量与实时评分场景

技术要求

第七章**，使用多模型解决方案加速器，涉及大量的复杂 Python 编程。本章提供了一些喘息的机会；你将不会进行编码，而是通过阅读业务场景和应用适当的解决方案来学习重要的技能。因此，本章没有技术要求。

架构批量评分解决方案

批量推理是指在基于时间周期性重复的批次上对新数据点进行评分。随着时间的推移收集新数据，然后进行评分，生成新的预测。这是现代公司使用机器学习模型最常见的方式。

在本节中，你将学习如何使用 Azure AutoML 训练的模型架构一个完整的、端到端的批量评分解决方案。你还将了解为什么以及在什么情况下应该优先考虑批量评分而不是实时评分解决方案。

理解五步批量评分流程

您制作的每个批量评分解决方案都应该遵循一个五步流程。这个过程从使用 AMLS 训练并注册一个机器学习模型开始，就像您在前几章中所做的那样。回归、分类和预测模型都遵循相同的模式。依次的五步如下：

训练模型。您可以使用与第三章**“训练您的第一个 AutoML 模型”中相同的方式，使用 AMLS 图形用户界面进行模型训练，或者使用计算实例上的 Python 进行训练，就像在第四章“构建 AutoML 回归解决方案”、*第五章“构建 AutoML 分类解决方案”和*第六章**“构建 AutoML 预测解决方案”中所做的那样。
注册您的模型。同样，您可以使用 AMLS 图形用户界面或通过在计算实例上运行的 Python 来完成这项任务。注册一个模型将其保存到您的 AMLS 工作空间，并允许您稍后引用它。
确定时间表。批量推理的常见时间表是每小时、每周或每月，尽管您可能需要根据业务问题的需求更频繁或更少地安排它。
批量评分数据。批量大小可以从一个数据点到一次处理数十亿个数据点不等。这一步是您运行批量推理代码的地方。在 Azure 中，我们使用机器学习管道。您将在*第九章**“实现批量评分解决方案”中学习如何编码机器学习管道。
交付结果。一旦您运行了机器学习管道并做出了新的预测或预测，您需要将这些结果发送到报告或数据库。在 Azure 中，使用名为Azure Data Factory（ADF）的工具将 AMLS 的结果发送到其他数据库。您将在*第十章**“创建端到端 AutoML 解决方案”中学习如何使用 ADF。

图 8.1展示了整个端到端过程。虽然您将为您的 AutoML 训练模型实现批量推理解决方案，但您可以使用相同的过程部署任何机器学习模型。确保您解决方案成功的关键在于将您的批量作业时间表与您的业务需求相匹配：

图 8.1 – 批量评分过程

现在您已经了解了这个过程，是时候深入了解每一步了。您已经熟悉了训练 AutoML 模型并将它们注册到您的 AMLS 工作空间中。接下来，您将学习在确定批量评分解决方案的时间表时需要考虑哪些因素。

安排您的批量评分解决方案

最终，你已经训练了一个 AutoML 模型来满足某些商业目标。也许你需要决定保留哪些产品以及淘汰哪些产品。也许你需要预测下季度的产品需求。你可能负责一支职业体育队伍，需要决定为即将到来的赛季挑选哪些球员。无论如何，你需要确保以合理的方式安排你的批量推理作业，以满足你的商业需求。

确定何时安排你的作业的关键基于三个因素：

商业需要做出决策的频率
数据可用性
你的批量评分作业运行所需的时间

首先，你需要知道业务多久做出一次决策，以帮助你的模型。对于一个职业体育队伍做出选秀决策的情况，这意味着你只需要每年运行一次作业。如果你为一家每季度决定其产品组合的企业工作，你的产品需求模型应该安排每年运行四次。同样，如果你为一家快餐店构建了一个模型，告诉他们为下一小时准备什么食物，你的批量推理解决方案应该每小时运行一次。你运行模型频率被称为模型节奏。

其次，你需要确保有新的数据可供你的模型评分。这被称为数据可用性。即使你的业务问题要求每小时做出新的预测，如果你的数据只每天刷新一次，你应该构建一个每天评分一次数据的模型。换句话说，你需要训练一个预测 24 小时并每天评分一次的预测模型，而不是一个预测 1 小时并每天运行 24 次的预测模型。始终在项目开始时确定数据可用性。这将为你节省大量时间。

最后，你需要注意你的批量作业运行的时间。即使你希望每 5 分钟评分一次数据，并且每 5 分钟就有新的数据可用，如果你的批量评分作业需要 10 分钟才能完成，你将限制评分和交付结果的频率。在这种情况下，考虑切换到实时解决方案。

一旦你确定了模型的节奏、数据的可用性以及你的批量作业运行所需的时间，下一步就是确定你的作业应该在何时运行——精确到秒。

在一个理想的世界里，你会在所有相关数据都可用时才运行你的模型。对于职业体育的例子，你希望拥有所有选秀球员的数据。对于每小时餐厅数据，你希望有最新的客流量、销售额、天气和交通数据来做出你的预测。

然而，在现实世界中，您应该始终预期会出现数据可用性问题。某些玩家数据可能会随机缺失。有时，天气或人流量数据可能会无故迟到。销售数据可能会因取消订单或信用额度用尽而损坏。因此，您应该简单地安排您的作业在最后可能的一刻运行。确保您包括一个缓冲时间来考虑计算集群启动时间。

计算集群的启动时间可能会有很大差异，因此您在解决方案上运行大量测试以了解启动所需的最大时间是很重要的。将您的缓冲时间设置为集群启动所需的最大时间，只要这看起来合理。通常，这不应超过 5 到 10 分钟。如果需要更长的时间，请提交支持工单。这样，您可以确保您的作业始终按时运行。

重要提示

虽然您可以设置您的最小计算集群节点数为1以实现更快、更一致的加速时间，但这意味着您每天 24 小时、每周 7 天都在付费，抵消了批量解决方案固有的成本节约优势。将计算集群节点数设置为0将随着时间的推移带来实质性的成本节约。

通过安排您的作业在业务将审查您的预测以协助其决策的同一时间运行，您为上游系统收集、转换和修复数据提供了尽可能多的时间。您还基于最新的数据提供了尽可能好的预测。您还需要考虑如何批量评分数据。

批量评分数据和交付结果

在 AMLS 中，批量评分发生在 ML 管道内。ML 管道要求您指定一个环境，编写一个评分脚本以访问您的模型，并将结果写入数据存储，最可能的是写入 Azure 存储账户中 blob 容器上的文件系统，以 CSV 文件的形式。您将在第九章“实现批量评分解决方案”中学习如何完成所有这些操作。

然而，运行机器学习（ML）管道仅仅生成和存储预测结果。这并不等同于交付结果。直接咨询业务部门是确定您的数据最终应放置何处的最佳方式。有时，他们可能希望您将预测存储在他们可以直接访问的 SQL 数据库中。其他时候，他们可能希望通过电子邮件收到 Excel 文件。通常，他们会要求您将结果推送到他们可以通过移动设备访问的 Web 应用程序。

AMLS 本身可以直接将结果写入 Azure Data Lake Storage 账户（第一代和第二代）、Azure SQL 数据库、Azure Blob 存储、Azure 文件共享、Azure PostGreSQL、Azure Database for MySQL 和 Databricks 文件系统。ML 管道可以直接将这些类型的数据存储移动到这些存储中。但这仅限于此；仅使用 ML 管道无法直接将数据从 Azure 中移出。

通常情况下，商业人士会要求你在其他地方落地你的 AutoML 模型的结果，例如本地数据库或文件共享。ADF 是移动数据进入和离开 Azure 的完美工具。你将在第十章“创建端到端 AutoML 解决方案”中学习如何使用 ADF 来解决这个问题。

理解这个过程是第一步。接下来，你需要了解何时以及为什么应该使用批量评分解决方案而不是它们的实时对应方案。

选择批量而非实时

实时解决方案在数据点到来时立即对它们进行评分。与批量不同，不需要等待计算集群启动；实时评分集群永远不会关闭。一旦新数据到来，新的预测就会自动生成。虽然这似乎是批量评分的一个有吸引力的替代方案，但有两个主要原因你应该优先考虑批量推理而不是实时推理：成本和复杂性。

在使用云计算时，你只有在需要时才为资源付费。对于批量推理，当你的作业运行时，一个计算集群会启动，一旦作业运行完成，它就会关闭。对于实时推理，你的集群将全天候运行，每周 7 天。这意味着实时推理解决方案的成本比它们的批量推理等效方案高得多。

复杂性也是一个关键问题。对于批量解决方案，你只需要将新数据移动到你的 Azure 数据存储中，对其进行评分，然后发送到另一个数据库进行最终交付。这是一个简单、可重复的模式，适用于广泛的问题。

另一方面，实时解决方案从来都不是那么简单直接。任何实时解决方案的核心都是一个评分端点。这些端点可以在任何代码的任何地方使用。有时，你可能希望将它们集成到 Web 应用程序中；其他时候，你可能希望将它们集成到支持持续流动数据的应用程序中。而批量评分解决方案遵循的是一种标准模板，实时解决方案通常更复杂且独特。

回顾一下，批量评分解决方案相对于实时解决方案有以下优势：

运行成本更低。
结构更简单。
它们很容易复制，因为它们遵循一个模板。

现在你已经了解了批量推理解决方案是什么以及为什么应该使用它们，是时候看看实时解决方案了。实时解决方案不像批量解决方案那样普遍，但它们确实专门支持大量的用例。它们也非常强大，需要深思熟虑，并且创建起来很有趣。

架构实时评分解决方案

实时推理指的是在数据点到达时进行评分，而不是基于时间表进行评分。新数据流入，新的预测结果产生。虽然不如批量推理常见，但实时推理在许多场景中被公司使用，例如信用卡欺诈检测、工厂地面的异常检测，以及在线购物时推荐产品。

在本节中，您将学习如何使用 Azure AutoML 训练的模型构建一个完整、端到端的实时评分解决方案。您还将了解为什么以及在什么情况下，您应该优先考虑实时评分而不是批量评分解决方案。

理解四步实时评分过程

实时评分解决方案遵循与批量评分解决方案略有不同的流程。只有四个步骤。与批量解决方案一样，该过程从训练一个 ML 模型并将其注册，就像您在前几章中所做的那样开始。您可以使用任何类型的 ML 模型，包括回归、分类和预测，它们都遵循相同的模式。以下四个步骤如下：

训练模型。当训练用于实时部署的模型时，请特别注意在评分时模型将可用的数据。错误地包含那些实际上不会始终可用给实时解决方案的数据是很常见的。
注册您的模型。您可以使用 AMLS 图形用户界面或在一个计算实例中运行的 Python 代码进行注册。
实时评分数据。这一步是您运行实时推理代码的地方。在 Azure 中，我们使用 AKS 创建实时评分端点。您将在第十一章“实现实时评分解决方案”中学习如何创建和使用 AKS 以及实时评分端点。
交付结果。实时交付结果与批量交付结果有很大不同，并且取决于问题。通常，结果将显示在某个面向用户的应用程序上。在其他情况下，您的结果将被输送到一个数据库中，如果满足条件，则会触发警报。想想看，如果算法检测到您的账户上有欺诈性的信用卡使用，您可能会收到短信。

图 8.2显示了整个端到端过程。虽然您将为 AutoML 训练的模型实现实时推理解决方案，但您可以使用此相同的过程来实时部署任何 ML 模型。确保您解决方案成功的关键在于将您的实时解决方案与您的业务需求相一致：

图 8.2 – 实时评分过程

现在您已经了解了这个过程，是时候深入了解每个步骤了。首先，您需要回顾为实时部署训练模型时的独特考虑因素。

为实时部署训练模型

当你使用 AutoML 或自定义 ML 模型训练用于实时部署的模型时，最重要的考虑因素是数据可用性。批量评分解决方案并不经常运行；数据会积累，你一次将它们全部传递。在实时解决方案中，数据不断生成和评分。因此，你需要问自己，你的解决方案是否始终能够及时访问数据。

一个很好的例子是按分钟实时评分快餐产品需求。需求的最大预测因素之一是当前排队在快车道上的汽车数量。如果你有可靠的视频技术可以记录汽车、计数并将它们按分钟传递到你的实时评分端点，那么你应该使用这些数据。然而，如果视频流需要 3-5 分钟才能传递这些数据，那么你不应该用它进行按分钟评分。

因此，在每一个项目的开始阶段，你应该花大量时间去弄清楚你将何时以及如何获得哪些数据。这是另一种数据可用性问题。如果你的数据将在评分的节奏下可用，请使用它。如果不行，请丢弃它。此外，如果由于可靠性问题（例如，一个经常返回空值的天气 API）数据有时才可用，请丢弃它。

你现在应该对数据可用性对于实时评分的重要性有了一个明确的理解。现在是时候考虑你应该如何评分数据和交付结果了。

实时交付结果

使用 AMLS 创建实时解决方案意味着创建一个由 AKS 托管的实时评分端点。你将在第十一章“实现实时评分解决方案”中了解更多关于这个主题的内容。评分端点是一个你可以传递数据以生成预测的 Web 服务。一旦创建，你可以在任何代码片段中放置这些端点。

通常情况下，实时评分解决方案的结果将被嵌入到应用程序中。在考虑交付时，你应该始终考虑以下三个因素：

是人类还是自动化系统接收你的预测？
人类将如何接收你的结果？
自动化系统会对你的预测做些什么？

在人类接收你的预测的情况下，你需要确定他们期望如何接收它们。通常，是通过他们可以在 PC 或移动设备上访问的应用程序。餐厅中的预测可能显示在面向员工的店内应用程序上。工厂车间的预测可能发送到移动设备上。

在您的预测被发送到自动化系统的情况下，您需要弄清楚系统是否会根据某些事件向人类发送警报，或者预测是否仅用于控制某些流程。如果是后者，您只需要编写将预测移动到该流程使用的适当数据库的代码。

另一方面，如果自动化系统需要向人类发送警报，您需要决定人类将收到哪些事件的警报。以信用卡欺诈检测为例。您只想提醒用户有欺诈交易；您不希望他们被每个交易的警报淹没。

考虑到交付的重要性，您接下来需要深入了解何时使用实时评分解决方案而不是它们的批量等效方案。

了解何时使用实时评分

批量推理是数据科学家使用的默认评分类型。这是因为它成本低、可靠且易于复制。然而，许多情况要求实时推理。关键问题是，"一旦数据可用，我需要多少时间给业务部门提供预测？"这实际上是最重要的考虑因素。从新数据可用并准备好评分的那一刻起，如果用户期望在无法通过批量评分实现的时间内获得结果，就必须使用实时评分。

考虑这样一个案例，用户将数据发送到基于 Web 的应用程序，并在屏幕上返回预测。在这种情况下，如果您使用批量处理，预测可能需要 5 到 15 分钟才能显示在屏幕上。这是因为计算集群需要时间启动，环境需要一点时间来创建，而您的代码需要时间运行。

然而，如果您使用实时评分，则只需运行您的代码，这大大减少了总运行时间。如果您的用户期望几乎即时的结果，您需要构建实时解决方案。如果他们愿意等待，那么您应该构建更便宜的批量解决方案。

重要提示

在选择实时解决方案的 CPU 时，始终选择最便宜的，它可以在及时的方式下评分您的数据。虽然更强大的 CPU 可能会节省您的时间，但它们每个月也会额外花费数百美元，每个月您的解决方案存在。

其他需要实时解决方案的常见场景包括交易欺诈检测、工厂环境中的异常检测以及推荐引擎。这是因为这些情况需要一旦数据可用就立即进行预测。再次强调，这是关键考虑因素。然而，也存在一些情况，批量处理可能更为合适。

考虑异常检测的案例。如果你在工厂车间有众多机器运行，并且需要知道何时有一台机器损坏以便你能够立即用备用机器替换它，这种情况需要实时解决方案；关键词是立即。你越快用备用机器替换损坏的机器，你的工厂表现越好，节省的金钱越多。

另一方面，想象一下，这些机器也显示出磨损的迹象，并且几天前，你可以安排工程师来维修以保持它们正常运行。在这种情况下，你仍然会使用异常检测机器学习解决方案来检测何时需要维护机器，但你应该批量评分数据。这是因为没有迫切需要立即修复机器。因此，你应该每天在一天结束时评分数据，并按需安排工程师。

你在创建实时评分解决方案方面获得的经验越多，你就能越准确地判断何时是必需的。始终问自己，“一旦我的数据可用，我的客户能等多久才能得到预测？”如果他们可以等待，就构建一个批量解决方案。如果他们不能等待，就构建一个实时解决方案。

在决定使用哪种类型的解决方案时，还有一些其他因素需要考虑。

选择实时而非批量解决方案

总结一下，如果没有迫切需要在数据到达时立即评分，批量解决方案应该始终优先于实时解决方案。这是因为实时评分解决方案本质上比批量评分解决方案更昂贵，因为你的计算集群永远不会关闭。另一方面，如果迫切需要在数据可用时立即评分，你需要使用实时解决方案来避免批量过程中固有的延迟。

复杂性也是一个问题。批量评分解决方案总是遵循相同的模板：收集数据，评分数据，将结果发送到某个文件或数据库。实时解决方案并非如此；它们需要仔细集成到应用程序中。以下比较了实时和批量评分解决方案：

图 8.3 – 比较批量和实时评分

能够理解批量和实时评分解决方案之间的区别是一回事；能够运用这种知识是另一回事。在下一节中，你将测试你的知识。

确定批量与实时评分场景

当面对实际业务案例时，往往很难区分你应该如何部署你的机器学习模型。许多数据科学家在需要实时解决方案时错误地实现了批量解决方案，而其他人则在更便宜的批量解决方案就足够的情况下实现了实时解决方案。

在以下各节中，您将查看不同的问题场景和解决方案。阅读这六个场景，并确定您是否应该实施实时或批量推理解决方案。首先，您将查看每个场景。然后，您将阅读每个答案及其解释。

实时或批量评分的场景

在本节中，您将看到六个场景。仔细阅读每个场景，并决定批量评分解决方案或实时评分解决方案哪个更合适。

场景 1 – 需求预测

一家快餐公司正在尝试确定在任何给定的一天需要多少袋冷冻薯条。您的机器学习回归算法生成的预测将用于确定每个地点需要多少袋薯条。每周一次，车队将从位于中心的仓库将薯条运送到每个商店。您的评分解决方案应该是实时处理还是批量处理？如果是批量处理，那么应该多久评分一次新数据？

场景 2 – 基于网络的供应链优化应用程序

一家化工公司正在尝试优化其供应链，并在每个仓库都设有操作员。他们每天都会将数据输入到基于网络的应用程序中，该应用程序将用于确定第二天送货路线。

您的机器学习回归算法生成的预测将预测每条可能路线的总盈利能力，并生成最佳路线。预计操作员每天会手动将数据输入到应用程序中。这个解决方案应该是批量处理还是实时处理？如果是实时处理，那么它将带来哪些好处？

场景 3 – 欺诈检测

一家信用卡公司正在实施欺诈检测算法。最近，客户报告了许多可疑交易，并因此离开。一旦检测到欺诈活动，公司希望立即阻止交易并通知客户他们的交易已被阻止。

您的机器学习分类算法生成的预测将阻止任何可疑交易，并将发送短信到客户的手机。这个解决方案应该是批量处理还是实时处理？如果是批量处理，那么应该多久评分一次新数据？

场景 4 – 预测性维护

一家汽车公司正面临机器故障的问题。每次机器出现故障，整个生产线都会停工等待机器修复，这给公司造成了数万美元的损失。大约每个月一次，工程师会对机器进行维护，但工程师的数量仅足以修复 20%的机器。

您的机器学习分类算法将告诉这些工程师哪些机器需要维修，并按优先级安排维修。这个解决方案应该是批量处理还是实时处理？如果是批量处理，那么应该多久评分一次新数据？

场景 5 – 基于网络的成本规划

一家航空航天公司正在尝试预测一款新飞机系列的盈利能力，并希望根据规格预测原材料和劳动力的成本。定价经理将手动将相关数据输入到基于网络的程序中，并希望立即从您的机器学习回归算法中看到预测价格。他们没有固定的时间来做这件事，他们可能在单个会话中多次运行该程序。

您应该设计这个解决方案为批量还是实时？如果是批量，应该多久评分一次新数据？

场景 6 – 推荐引擎

一家零售店正在建立一个网站。当客户浏览并添加新项目到他们的购物车时，该店希望向这些客户推荐其他要购买的项目。您的机器学习回归算法将根据客户浏览的内容实时为项目分配分数，得分最高的项目将自动显示给他们。这个解决方案应该设计为实时还是批量？如果是批量，应该多久评分一次新数据？

深入思考每个场景，然后继续下一节。

每个场景适合的解决方案类型答案

在本节中，您将回顾每个六个场景的答案。阅读每个解释，然后回顾原始场景以获得清晰。

场景 1 – 批量推理解决方案

场景 1 是机器学习的典型案例。快餐公司希望每周预测薯条的销量。数据来自所有门店，应每周使用批量推理过程进行评分。一旦生成预测，薯条就可以装上卡车，并运送到所有门店。

这是一个批量解决方案，因为数据只需要每周评分一次，而且没有迫切需要在数据可用时立即生成预测。

场景 2 – 批量推理解决方案

场景 2 可以使用实时或批量推理解决方案。当操作员手动将数据输入到基于网络的程序中时，这仅仅是一个他们愿意等待多长时间的问题。由于这是一次性每日操作，结果将在第二天使用，因此最好是牺牲时间换取金钱，选择批量推理过程。然而，如果您在这个场景中构建了一个实时解决方案，这将有一个好处。操作员可以立即看到结果，而无需等待 10 到 15 分钟。

场景 3 – 实时推理解决方案

场景 3 是一个经典的实时推理用例。欺诈交易必须立即检测到，也就是说，一旦交易数据可用。这种速度使得交易可以立即被阻止，并且客户可以尽快收到通知。

批量推理解决方案无法提供所需的速度。此外，每个数据点都必须在到达时单独评分。没有时间将数据批量汇总，或者启动计算集群。

场景 4 – 批量推理解决方案

场景 4 是一个棘手的情况。预测性维护有时可能需要实时推理，尤其是在异常检测表明即将发生故障并且有应急人员待命准备修复问题时。

然而，在这种情况下，工程师们每月只能服务一次机器。因此，没有迫切需要立即的结果。对于这种情况，每月一次的批量处理解决方案最为合适。

场景 5 – 实时推理解决方案

场景 5 与场景 2 类似，但有三个主要区别：

定价经理不会按照固定的时间表运行评分解决方案。
定价经理可能会在一个设置中多次运行该解决方案。
定价经理期望立即得到结果。

立即的结果应该让你知道这是一个 实时评分解决方案。如果你用批量处理设计了此解决方案，每次定价经理运行他们的数字时，他们都会经历长时间的等待。你可以改变应用程序以使其更友好地处理批量的一种方法就是允许定价经理一次输入所有场景的数据，而不是逐个输入。

场景 6 – 实时推理解决方案

场景 6 是另一个经典的实时推理场景。推荐引擎需要非常快，并根据用户点击、查看和添加到购物车的内容进行变化。它们还需要根据客户购买的内容进行变化。每次屏幕变化时，都必须对新的数据进行评分，以便向用户展示适当的商品。性能也非常重要，因为算法必须跟上用户的行为。每个由机器学习驱动的推荐引擎都应该在实时下使用。

你在六个场景中的表现如何？你是否达到了 100% 的准确率？无论哪种情况，看看 图 8.4 以了解常见场景如何映射到实时或批量评分解决方案：

图 8.4 – 常见场景如何映射到实时或批量处理

如果你第一次尝试就能准确地决定哪种评分解决方案适合你的每个场景，那么你已经顺利通过了。你现在对哪些情况需要实时推理解决方案以及哪些情况需要批量推理解决方案有了深入的理解。如果你在一个或多个场景中犯了错误，请重新阅读所有场景，直到你直觉上理解了它们之间的区别。

记住，决定使用哪种类型解决方案的最重要因素是相对于数据何时可用，你需要预测的速度有多快。如果最终用户可以等待，请使用批处理。如果应用程序需要即时响应，请使用实时。理解这种差异不仅会使你成为一名优秀的数据科学家，而且还能为你和你的组织节省时间、金钱和精力。

摘要

你现在对批处理和实时推理有了牢固的理解，以及何时使用哪种类型的评分解决方案。这很重要，因为即使是经验丰富的数据科学家在设计端到端 ML 解决方案时偶尔也会犯错误。

此外，大多数 ML 课程都侧重于模型训练而不是部署，但要想成为一名有效的数据科学家，你必须在这两方面都精通。在接下来的章节中，你将学习如何在 AMLS 中编写这些推理方法的代码。

在第九章**，实现批评分级解决方案中，你将逐步学习如何使用你已构建的 ML 模型在批评分级场景中。你将在 AMLS 中创建 ML 管道，并学习如何安排它们在定时器上运行。这将使你能够轻松地将你的 ML 模型投入生产，并成为你公司或组织的宝贵资产。

第九章：实现批量评分解决方案

你已经在 Azure 中用 AutoML 训练了回归、分类和预测模型，现在是时候学习如何将它们投入生产并使用了。毕竟，机器学习（ML）模型最终是用来对新数据进行预测的，无论是在实时还是在批量中。为了在 Azure 中批量评分新数据点，你必须首先创建一个机器学习管道。

机器学习管道允许你在Azure 机器学习服务（AMLS）中运行可重复的 Python 代码，你可以在计划中运行这些代码。虽然你可以使用机器学习管道运行任何 Python 代码，但在这里，你将学习如何构建用于评分新数据的管道。

你将从此章节开始，编写一个简单的机器学习管道，使用在第五章“构建 AutoML 分类解决方案”中训练的 Iris 数据集的多分类模型来评分数据。使用相同的数据，你将学习如何并行评分新的数据点，从而让你能够快速同时评分包含数百万到数十亿数据点的模型。

一旦编写了这两个管道，你将学习如何创建用于重新训练 AutoML 模型的机器学习管道。最后，你将学习如何通过 GUI 手动和通过Azure ML SDK编程方式重新触发机器学习管道。

到本章结束时，你不仅能够训练 AutoML 模型，而且能够以可重复、可自动化的方式使用它们来评分新数据。此外，你在这里学到的代码和技术适用于所有机器学习模型，而不仅仅是 AutoML 生成的模型。编写批量评分解决方案是任何机器学习工程师的关键技能，通过完成本章的练习，你将朝着掌握这一技能迈出重要一步。

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

创建机器学习管道
创建并行评分管道
创建 AutoML 训练管道
触发和安排你的机器学习管道

技术要求

本章将使用 AMLS 中的 Jupyter 笔记本进行大量编码。因此，你需要一个有效的互联网连接、一个AMLS 工作空间和一个计算实例。机器学习管道还需要一个计算集群。你还需要在第五章“构建 AutoML 分类解决方案”中训练并注册 Iris 多分类模型。

本章的先决条件如下：

访问互联网。
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium。
一个 Microsoft Azure 账户。
已创建一个 AMLS 工作空间。
在第二章，“Azure 机器学习服务入门”中创建了compute-cluster计算集群。
了解如何从 Azure 计算实例导航到 Jupyter 环境的方法，如 第四章，构建 AutoML 回归解决方案 中所示。
在 第五章，构建 AutoML 分类解决方案 中训练并注册了 Iris-Multi-Classification-AutoML 机器学习模型。

本章的代码在此处可用：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/tree/master/Chapter09。

创建一个机器学习流程

机器学习流程是 Azure 的批量评分机器学习模型的解决方案。你可以使用机器学习流程来评分你训练的任何模型，包括你自己的自定义模型以及 AutoML 生成的模型。它们只能通过使用 Azure ML Python SDK 的代码来创建。在本节中，你将编写一个简单的流程来使用你在 第四章，构建 AutoML 回归解决方案 中构建的 Diabetes-AllData-Regression-AutoML 模型来评分糖尿病数据。

如其他章节所述，你将首先打开你的计算实例并导航到你的 Jupyter 笔记本环境。然后创建并命名一个新的笔记本。一旦你的笔记本创建完成，你将逐步构建、配置和运行一个机器学习流程。确认你的流程成功运行后，你将然后发布你的机器学习流程到流程端点。流程端点只是 URL，是调用机器学习流程运行的网页地址。

以下步骤与之前的章节有很大不同。你将需要加载更多的库，并编写一个用于评分新数据的自定义 Python 文件。你还将学习如何创建环境，即指定你使用的 Python 包、包版本和软件设置的工件。

除了创建环境之外，你还需要对其进行容器化。最后，你需要配置并运行你的机器学习流程，通过将流程发布到端点来完成整个过程。整个过程在 图 9.1 中展示：

图 9.1 – 创建你的机器学习评分流程所涉及的步骤

GitHub 仓库中的 ML-Scoring-Pipeline.ipynb 文件包含了所有步骤的代码。

编写你的机器学习评分流程的前三个步骤

首先，加载你的库，设置你的 AMLS 资源，并按照以下步骤创建一个用于评分的数据集：

通过导航到 ml.azure.com/ 打开 Azure 机器学习工作室（AML 工作室）。
点击计算并启动一个计算实例。任何计算实例都可以，因为它们都链接到相同的 Jupyter 笔记本环境。
创建一个新的 Jupyter 笔记本，并将其命名为 machine-learning-pipeline。如果你需要复习如何做这件事，请查阅 第四章，构建 AutoML 回归解决方案。
打开你刚刚创建的笔记本，并开始使用以下代码导入你将需要的所有标准 Azure 库：
```
from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment, Environment, Model
from azureml.core.compute import ComputeTarget
```
第四章，构建 AutoML 回归解决方案，解释了 Workspace、Dataset、Datastore、Experiment 和 ComputeTarget。Environment 允许你创建一个对象，其中包含有关你的 ML 管道需要安装哪些 Python 包以成功运行的信息。Model 允许你检索之前训练的 ML 模型。
继续导入所有 Azure ML 管道库，使用以下代码：
```
from azureml.core.runconfig import RunConfiguration, CondaDependencies, DEFAULT_CPU_IMAGE
from azureml.pipeline.steps import PythonScriptStep
from azureml.pipeline.core import Pipeline, PublishedPipeline
from azureml.pipeline.core import StepSequence
from azureml.widgets import RunDetails
```
RunConfiguration 存储了你的 ML 管道运行所需的信息，包括环境和基础镜像。CondaDependencies 允许你向环境中添加 Python 包。Default_CPU_Image 用于指定你在运行配置中将要使用的基础镜像。PythonScriptStep 是 Pipeline 类型，是构建 ML 管道的核心包。PublishedPipeline 允许你将 ML 管道发布到端点。StepSequence 允许你设置 ML 管道步骤的顺序，而 RunDetails 则简单地显示你的 ML 管道在运行时的输出。

重要提示

如果你加载任何 Azure 库时遇到困难，请通过运行此处找到的 Update AzureML SDK.ipynb 笔记本来更新 Azure ML SDK：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Update-AzureML-SDK.ipynb。
导入 pandas、numpy 和 os。os 允许你从 Jupyter 笔记本中创建和操作文件和文件夹。random 允许你生成随机数，这对于模拟新的鸢尾花数据很有用：
```
import pandas as pd
import numpy as np
import os
import random as r
```
将你的 Jupyter 笔记本连接到你的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果你被提示登录，请按照说明操作。
将你的计算集群设置为你在 第二章，Azure 机器学习服务入门 中创建的那个：
```
compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)
```
设置你的数据存储：
```
datastore = Datastore.get_default(ws)
```
接下来，你将创建用于评分的模拟鸢尾花数据。首先，使用以下代码创建四个变量，这些变量包含基于原始鸢尾花数据集最小值和最大值的数字列表。这些变量包含鸢尾花数据集中所有可能的值：
```
sepal_length_range = np.arange(4.3, 7.9, 0.1)
sepal_width_range = np.arange(2, 4.4, 0.1)
petal_length_range = np.arange(1, 6.9, 0.1)
petal_width_range = np.arange(0.1, 2.5, 0.1)
```
在创建模拟的鸢尾花数据集的过程中继续，创建一个名为 IrisDF 的空 pandas DataFrame，并包含适当的列名。同时，创建一个名为 IrisList 的空列表：
```
columns =\ ['sepal_length','sepal_width','petal_length','petal_width']
IrisDF = pd.DataFrame(columns=columns)
IrisList = []
```
在创建模拟的鸢尾花数据集的过程中继续，使用 random 包中的 choice 函数在 for 循环中创建 100 个新的数据点，并将每个值四舍五入到 1 位小数。

在 for 循环中，将每组四个数据点与 Python 字典中的列名组合，并将该字典逐行追加到 IrisList：
```
for i in range(0,100):
    values = \
[round(r.choice(sepal_length_range),1),round(r.choice(sepal_width_range),1),round(r.choice(petal_length_range),1),round(r.choice(petal_width_range),1)]
    iris_dictionary = pd.DataFrame(dict(zip(columns, values)),index=[0])
    IrisList.append(iris_dictionary)
```
此代码将为您留下从原始 Iris 数据集中随机生成的值列表，这些值可以转换为 pandas DataFrame。
完成模拟 Iris 数据的创建，将 IrisList 追加到 IrisDF：
```
IrisDF = IrisDF.append(IrisList,True)
```

使用以下代码注册您的模拟 Iris 数据：

Dataset.Tabular.register_pandas_dataframe(IrisDF, datastore, 'Iris_Scoring')

这将将其保存到您的数据存储中，并创建一个名为 Iris Scoring 的 Azure 数据集。

创建一个用于在您的机器学习管道中评分数据的 Python 脚本

在本节中，您将创建一个文件夹并编写一个 Python 脚本，您的机器学习管道将执行该脚本以评分数据，具体步骤如下：

使用 os 创建一个用于存放评分脚本的文件夹：
```
os.makedirs('Scoring_Scripts', exist_ok=True)
```
对于您做出的每个机器学习管道步骤，您都必须有一个相应的 Python 脚本。
编写一个用于评分新数据的 Python 脚本。此脚本很长，必须是一段代码块。首先，使用 %%writefile 魔法命令编写一个新的 Python 脚本文件，名为 Iris_Scoring.py。Run 允许您的程序在远程计算集群上运行时访问您用于创建机器学习管道的 AMLS 工作区。
在 Iris_Scoring.py 的同一单元格中继续，导入其他 Python 包：
```
import joblib
import numpy as np
import pandas as pd
import os
```
这里唯一的新包是 joblib，它将允许您加载保存的机器学习模型。
在 Iris_Scoring.py 的同一单元格中继续，使用 Run 函数设置一个名为 run 的变量。您可以使用此变量设置您的 AMLS 工作区：
```
run = Run.get_context()
```
在 Iris_Scoring.py 的同一单元格中继续，我们将创建一个名为 main 的函数。此函数将运行您的评分代码的主要部分。

首先，使用您创建的 run 变量连接到您的 AMLS 工作区。接下来，将数据存储设置为默认选项，并将数据集设置为 Iris Scoring。将 Iris Scoring 数据集转换为名为 scoringDF 的 pandas DataFrame：
```
def main():
    ws = run.experiment.workspace
    datastore = Datastore.get_default(ws)
    dataset = Dataset.get_by_name(ws,'Iris Scoring')
    scoringDF = dataset.to_pandas_dataframe()
```
在 Iris_Scoring.py 的同一单元格中继续，使用 Azure 的 Model 和 joblib 包加载您的 Iris-Multi-Classification-AutoML 模型：
```
    model_path = Model.get_model_path('Iris-Multi-Classification-AutoML')
    model = joblib.load(model_path)
```
在 Iris_Scoring.py 的同一单元格中继续，使用您的模型对 scoringDF 进行预测，将这些预测保存到 pandas 的 Series 中，并将这些预测添加到您的 scoringDF DataFrame 的新列 Prediction 中：
```
    predictions = model.predict(scoringDF)
    predSeries = pd.Series(predictions)
    scoringDF['Prediction'] = predSeries
```
当您添加新列时，预测将按正确顺序排列，并与相应的行匹配。
在 Iris_Scoring.py 的同一单元格中继续，使用 os 创建一个名为 Output_Folder 的文件夹：
```
    output_datastore_path = 'Output_Folder'
    os.makedirs(output_datastore_path, exist_ok=True) 
```
这将在您的计算集群上创建一个文件夹，用于临时存储您的预测，以便您可以将其传输到您的数据存储。
在 Iris_Scoring.py 的同一单元格中继续，指定一个名为 Iris_Predictions.csv 的文件。然后，使用 os 在计算集群上指定一个路径，您将在此路径上写入该文件。最后，使用 to_csv 将 scoringDF 写入您的计算集群：
```
    FileName = "Iris_Predictions.csv"
    OutputPath = os.path.join(output_datastore_path, FileName)
    scoringDF.to_csv(OutputPath, index = False, sep=',')
```
这段代码将您的输出写入您的计算集群。这是必要的，以便将其移动到您的数据存储中。
在 Iris_Scoring.py 的同一单元格中继续，将 Iris_Predictions.csv 上传到您的数据存储。此代码将将其写入名为 Output_Folder 的文件夹中，与您的计算集群上的目录结构相匹配。
```
    datastore.upload_files(files=[OutputPath], target_path=output_datastore_path, overwrite=True)
```
完成 Iris_Scoring.py 后，使用 os 从您的计算集群中删除文件和文件夹。使用模板代码完成单元格，当 Python 脚本在 ML 管道中调用时，将自动运行您的 main 函数：
```
    os.remove(OutputPath)
    os.rmdir(output_datastore_path)
if __name__ == '__main__':
    main()
```

这就完成了您的 Python 脚本。在新的单元格中编写下一段代码。

创建和容器化环境

困难的部分已经结束，剩下的都是纯模板代码，从创建环境开始。环境是运行您的代码所需的 Python 包的集合：

在新单元格中创建一个环境。同时，使用 CondaDependencies 设置一个变量：
```
Env = Environment(name='AutoML Environment')
conda_dep = CondaDependencies()
```
在下一步中，将运行您的 Python 脚本所需的全部包及其版本添加到 conda_dep 变量中。
将 Python 包附加到您的 conda_dep 变量中，从 conda 包管理器中找到的包开始：
```
conda_dep.add_conda_package("numpy==1.18.5")
conda_dep.add_conda_package("joblib==0.14.1")
conda_dep.add_conda_package("pandas==0.25.3")
conda_dep.add_conda_package("packaging==20.7")
conda_dep.add_conda_package("xgboost==0.90")
```
有两个包管理器，conda 和 pip。conda 会自动为您解决依赖问题。因此，如果一个包需要另一个包，您无需担心。pip 则要求您自己解决这些依赖。结果，如果一个包在 conda 和 pip 中都可用，请始终通过 conda 安装它。

在安装包时，始终指定版本。您可以通过在空单元格中运行 !pip freeze 命令来发现您正在使用哪个版本。除了 numpy、joblib 和 pandas 之外，AutoML 生成的模型还需要 packaging 和 xgboost 来运行。
使用 pip 而不是 conda 将不可在 conda 中找到的 Python 包附加到您的 conda_dep 变量中：
```
conda_dep.add_pip_package("azureml-defaults==1.19.0")
conda_dep.add_pip_package("azureml-automl-core==1.19.0")
conda_dep.add_pip_package("azureml-automl-runtime==1.19.0")
```
有三个包；azureml-defaults 允许您使用标准的 Azure ML SDK 函数，而 azureml-automl-core 和 azureml-automl-runtime 是评分任何 AutoML 生成的模型所必需的。
将 conda_dep 变量添加到您的环境中，并使用以下代码将环境注册到您的 AMLS 工作区：
```
Env.python.conda_dependencies=conda_dep
RegisteredEnvironment = Env.register(workspace=ws)
```
现在您的环境已注册，您可以在 AMLS 的任何地方调用它。

为您的环境创建一个 RunConfiguration 对象以进行容器化。设置您的环境，启用 Docker，并使用 DEFAULT_CPU_IMAGE 作为基础镜像：

run_config = RunConfiguration()
run_config.environment = Env
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image =\
 DEFAULT_CPU_IMAGE

这将创建一个 Docker 容器，一个包含所有代码脚本和依赖项的可移植包，可以在任何地方运行。现在，您的环境可以通过您的 ML 管道使用，您将在最后一系列步骤中进行配置。

配置和运行您的 ML 评分管道

在你的环境构建并容器化，你的 Python 脚本编写完毕，以及所有你的 AMLS 资源设置完成后，你就可以按照以下步骤配置和运行你的机器学习流程：

使用以下代码配置你的机器学习流程步骤。你需要给你的步骤起一个名字，iris-scoring-step，并指定你的 Python 脚本名称、Python 脚本文件夹位置、计算目标和运行配置。始终将 allow_reuse 设置为 False：
```
scoring_step = PythonScriptStep(name='iris-scoring-step',
script_name='Iris_Scoring.py',
source_directory='Scoring_Scripts', 
arguments=[],
inputs=[],
compute_target=compute_target,
runconfig=run_config,
allow_reuse=False)
```
将 allow_reuse 设置为 True 是为了调试多步骤流程，其中你希望跳过重新运行已成功完成的步骤。
设置你的 步骤序列 和 流程对象：
```
step_sequence = StepSequence(steps=[scoring_step])
pipeline = Pipeline(workspace=ws, steps=step_sequence)
```
步骤序列是你的机器学习流程步骤将运行的顺序。
给你的流程实验运行起一个名字，Iris-Scoring-Pipeline-Run，并使用以下代码提交：
```
pipeline_experiment = Experiment(ws, 'Iris-Scoring-Pipeline-Run')
pipeline_run = pipeline_experiment.submit(pipeline, show_output=True)
```
最后，这是启动你的流程的关键步骤！
使用 RunDetails 来实时观察你的流程构建和执行：
```
RunDetails(pipeline_run).show()
pipeline_run.wait_for_completion(show_output=True)
```
在运行过程中，你会看到很多日志。如果你的流程运行成功，它将以完成的字样结束。你应该看到一个与 图 9.2 中相同的图形：

图 9.2 – 成功的流程运行图形
使用以下代码将你的流程发布到端点，指定一个名称、描述和版本号：
```
published_pipeline = pipeline_run.publish_pipeline(
    name='Iris-Scoring-Pipeline',\
    description='Pipeline that Scores Iris Data', version= '1.0')
published_pipeline
```
所有已发布的流程都需要由创建者设置的版本号。运行此代码将给你一个已发布的流程 ID 以及一个访问端点的链接，如图 图 9.3 所示：

图 9.3 – 成功发布的流程

现在你已经执行并发布了你的评分流程，你可以检查并下载你的评分文件。它被保存在一个名为 Output_Folder 的文件夹中，文件名为 Iris_Predictions.csv。通过导航到你的存储账户来直接访问该文件。你可以从 Azure 门户（portal.azure.com）或通过 AML 工作室 来这样做。

通过 AML 工作室访问你的评分预测

要访问 Iris_Predictions.csv 并将其下载到你的桌面，你首先必须定位你的存储账户。你可以通过 AML 工作室找到你的存储账户。

以下步骤将指导你通过 AML 工作室定位你的数据存储，访问你的存储账户，导航到正确的文件，并将其下载到你的本地机器。这样，你可以使用 AI 生成的预测来完成任何你希望的目的：

导航到 AML 工作室 ml.azure.com。
点击左侧面板上的 Datastores。
点击页面中央的蓝色链接到 workspaceblobstore（默认）。
点击页面下方 automlexamplew 后跟一串数字的蓝色链接到你的存储账户。这将带你到 Azure 中的存储账户资源。
一旦在你的存储账户中，点击屏幕中央左上角的蓝色链接到容器。
你现在将看到一个文件夹列表。点击以 azureml-blobstore- 开头并跟有一个唯一标识符 ID 的文件夹。
点击屏幕中央左边的 azureml、managed-dataset 和 UI。这些文件夹包含你的实验日志以及其他对象。图 9.4 展示了你需要遵循的文件夹结构以到达你的文件：

图 9.4 – 输出文件的路径
点击 Iris_Predictions.csv。
将 Iris_Predictions.csv 添加到你的本地机器。它是一个带有标题的逗号分隔文件。
使用 Microsoft Excel 或类似软件打开你的文件，查看你的数据。

这是一项繁重的工作，但现在你有一个可以批量评分新数据点的有效管道端点。这是一个巨大的成就，因为许多组织在设置此类工作流程时遇到困难。你还可以轻松地在多个项目中重用此代码，因为其中绝大多数是样板代码。虽然你必须修改 Python 脚本并添加适当的包，但此模板也可以用于评分 AutoML 和自定义机器学习模型。

接下来，你将学习如何使用并行评分管道在极短的时间内评分 1000 万个数据点。

创建并行评分管道

标准机器学习管道对于大多数机器学习用例来说效果很好，但当你需要一次性评分大量数据时，你需要一个更强大的解决方案。这就是 ParallelRunStep 的作用。ParallelRunStep 是 Azure 对批量评分大数据的回应。当你使用 ParallelRunStep 时，你可以同时利用计算集群上的所有核心。

假设你有一个由八个 Standard_DS3_v2 虚拟机组成的计算集群。每个 Standard_DS3_v2 节点有四个核心，因此你可以一次性执行 32 个并行评分过程。这种并行化实际上让你比使用单台机器快得多地评分数据。此外，它还可以轻松地进行垂直扩展（增加集群中每个虚拟机的大小）和水平扩展（增加节点数量）。

本节将帮助你成为一名能够评分大量数据的 大数据 科学家。在这里，你将再次使用模拟的 Iris 数据，但不是 100 行，而是一次性评分 1000 万行。

此外，这是一个利用两个管道步骤的高级解决方案，一个步骤是并行评分数据，另一个步骤是将数据传输到输出文件夹。通过完成这个示例，你会了解如何创建高级多步骤管道运行来解决复杂问题。

重要提示

并行运行以批处理方式评分数据，将您的数据集分成许多小部分。如果您有任何依赖于之前行计算的数据预处理，则应在传递到 ParallelRunStep 之前在单独的 PythonScriptStep 中完成此预处理。

这段代码的大部分与 创建机器学习管道 部分类似。然而，您需要创建两个管道步骤而不是一个。此外，您将接触到新的概念，例如 输入 和 输出 管道配置选项。在本节的末尾，您还将发布您的管道到端点。图 9.5 展示了整个流程：

图 9.5 – 创建并行评分管道涉及的步骤

如果您需要任何步骤的复习，请参阅 创建机器学习管道 部分。您可以在 GitHub 仓库中找到所有步骤的代码，位于 ML-Parallel-Pipeline.ipynb 文件。

编写您的机器学习并行评分管道的前三个步骤

要创建您的并行评分管道，请从以下步骤开始：

导航到您的计算实例上的 Jupyter 环境，创建一个新的 Jupyter 笔记本。将其命名为 ml-parallel-pipeline。

打开您新创建的笔记本并导入您的标准 Azure 库：

from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment, Environment, Model

从 azureml.core.compute 导入 ComputeTargetNext 并使用以下代码导入所有 Azure ML 管道库：
```
from azureml.core.runconfig import RunConfiguration, CondaDependencies, DEFAULT_CPU_IMAGE
from azureml.pipeline.steps import PythonScriptStep, ParallelRunStep, ParallelRunConfig
from azureml.pipeline.core import Pipeline, PublishedPipeline, PipelineData
from azureml.pipeline.core import StepSequence
from azureml.widgets import RunDetails
```
与上一节相比，有三个额外的包。ParallelRunStep 是一个机器学习管道步骤，允许您并行运行 Python 代码。ParallelRunConfig 允许您配置 ParallelRunStep。PipelineData 允许您将中间数据从一个步骤传递到另一个步骤。

重要提示

如果您在加载任何 Azure 库时遇到问题，请运行此处找到的 Update AzureML SDK.ipynb 笔记本以更新 Azure ML SDK：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Update-AzureML-SDK.ipynb。

导入 pandas、numpy、os 和 random：

import pandas as pd
import numpy as np
import os
import random as r

如往常一样，将您的 Jupyter 笔记本连接到您的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果您被提示登录，请按照说明操作。

使用以下代码设置您的计算集群：

compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)

设置您的数据存储：
```
datastore = Datastore.get_default(ws)
```

使用以下代码创建模拟的 Iris 数据：

sepal_length_range = np.arange(4.3, 7.9, 0.1)
sepal_width_range = np.arange(2, 4.4, 0.1)
petal_length_range = np.arange(1, 6.9, 0.1)
petal_width_range = np.arange(0.1, 2.5, 0.1)

继续创建模拟的 Iris 数据，创建一个空的 pandas DataFrame 和列表：

columns =\
['sepal_length','sepal_width','petal_length','petal_width']
IrisDF = pd.DataFrame(columns=columns)
IrisList = []

继续创建模拟的 Iris 数据，使用 random 包中的 choice 函数在 for 循环中创建 10,000,000 个新的数据点，每个值四舍五入到 1 位小数：

for i in range(0,10000000):
    values =\
[round(r.choice(sepal_length_range),1),round(r.choice(sepal_width_range),1),\
round(r.choice(petal_length_range),1),round(r.choice(petal_width_range),1)]
    iris_dictionary = pd.DataFrame(dict(zip(columns, values)),index=[0])
    IrisList.append(iris_dictionary)

这将需要一些时间，所以请给它一些运行的时间。

完成模拟 Iris 数据的创建，将 IrisList 添加到 IrisDF：
```
IrisDF = IrisDF.append(IrisList,True)
```

使用以下代码注册您的模拟 Iris 数据：

Dataset.Tabular.register_pandas_dataframe(IrisDF, datastore, 'Iris_Scoring')

这将把它保存到你的数据存储中，并创建一个名为Iris Parallel Scoring的 Azure 数据集。你现在可以编写你的 Python 脚本了。

创建用于在您的 ML 并行管道中评分数据的 Python 脚本

接下来，创建一个文件夹并编写两个 Python 脚本，你的 ML 管道将执行这些脚本来评分数据。你需要一个步骤来做出预测，另一个步骤将你的输出传输到数据存储上的最终目的地：

使用os创建一个文件夹来保存你的评分脚本：
```
os.makedirs('Scoring_Scripts', exist_ok=True)  
```
这个文件夹应该已经在上一节中存在，但由于exist_ok被设置为True，这段代码不会出错。这个文件夹将包含你将为你的并行管道运行编写的脚本。
编写一个 Python 脚本来并行评分新数据：
```
%%writefile Scoring_Scripts/Iris_Scoring.py
from azureml.core import Run, Workspace
from azureml.core import Dataset, Datastore, Model
```
这个脚本与之前的脚本有很大不同，但也要在一个单元格中完成。首先，使用%%writefile魔法命令编写一个新的 Python 脚本文件Iris_Parallel_Scoring.py。首先加载你的 Azure 库。你应该能从上一节中认出它们。
在Iris_Parallel_Scoring.py的同一单元格中继续，导入其他 Python 包，包括新的argparse包：
```
import os
import joblib
import argparse
import numpy as np
import pandas as pd
```
这个包允许你在脚本中传递参数。参数是灵活的代码片段，你可以在运行时将其传递到你的管道中。例如，你可以使用参数传递不同的数据存储或数据集。
在Iris_Parallel_Scoring.py的同一单元格中继续，使用Run函数设置一个名为run的变量：
```
run = Run.get_context()
```
在Iris_Parallel_Scoring.py的同一单元格中继续，创建一个名为init的函数。这个函数将传递你的参数并加载你的 ML 模型，将其设置为全局变量。

使用parser来存储你的参数，并将model_name参数添加到该变量中。ParallelRunStep在幕后还传递了隐藏的参数，因此你还需要设置unknown_args。完成这些后，使用joblib通过model_name参数加载你的模型，如下面的代码所示：
```
def init():
    parser = argparse.ArgumentParser()
    parser.add_argument('--model_name',\
    dest="model_name", required=True)
    args, unknown_args = parser.parse_known_args()
    global model
    model_path = Model.get_model_path(args.model_name)
    model = joblib.load(model_path)
```
在Iris_Parallel_Scoring.py的同一单元格中继续，创建一个名为main的函数。这个函数将评分你的数据并返回结果，该结果将被自动存储在一个名为parallel_run_step.txt.model的文件中，使用 Azure 的Model和joblib包。

首先，你将使用model变量的predict函数来做出预测。注意，数据会自动作为名为input_data的pandas DataFrame 传递到这个函数中。

然后将这些预测转换为序列，并将其添加回input_data作为名为Prediction的列。完成Iris_Parallel_Scoring.py后，你将返回完成的input_data DataFrame，它将被自动写入文本文件：
```
def run(input_data):
    predictions = model.predict(input_data)  
    predSeries = pd.Series(predictions)
    input_data['Prediction'] = predSeries 
    print('Data written to parallel_run_step.txt')
        return input_data 
```
编写一个 Python 脚本来将你的结果传输到你选择的输出位置。ParallelRunStep输出一个名为parallel_run_step.txt的文件。这将作为管道数据存储。

管道数据是在您的数据存储中保存的数据，作为传递给另一个机器学习管道步骤的中间步骤。此外，parallel_run_step.txt 没有标题，您需要添加它们。

首先使用 %%writefile 魔法命令编写一个新的 Python 脚本文件，名为 Iris_Parallel_Output_Creation.py。首先像往常一样加载您的 Azure 库：
```
%%writefile Scoring_Scripts/Iris_Parallel_Output_Creation.py
from azureml.core import Run, Workspace
from azureml.core import Dataset, Datastore
```
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，作为该脚本的一部分，加载您需要的所有标准 Python 包：
```
import pandas as pd
import numpy as np
import os
import argparse
```
您将再次需要 argparse 来传递参数，即包含 parallel_run_step.txt 的文件夹。
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，使用 Run 函数设置一个名为 run 的变量：
```
run = Run.get_context()
```
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，作为该脚本的一部分，传递您的参数以访问包含 parallel_run_step.txt 的文件夹：
```
parser = argparse.ArgumentParser()
parser.add_argument("--input_data_folder",type=str)
args = parser.parse_args()
```
调用 input_data_folder 参数，并在配置此管道步骤时将其作为参数传递：
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，作为该脚本的一部分，编写一个名为 main 的函数。此函数将把您的预测从中间管道数据位置转移到最终目的地。

首先使用 os 和 input_data_folder 查找包含 parallel_run_step.txt 的路径。然后，使用以下代码将其作为没有标题的空格分隔文本文件读取到名为 result 的 pandas DataFrame 中：
```
def main():  
    FileName = "parallel_run_step.txt"
    input_data_path =\
 os.path.join(args.input_data_folder, FileName)  
    result =\
 pd.read_csv(input_data_path, delimiter=" ", header=None)
```
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，作为 main 函数的一部分，向您的 result DataFrame 添加列：
```
    columns =\
['sepal_length','sepal_width','petal_length','petal_width', 'Prediction']
    result.columns = columns
```
重要的是要记住，parallel_run_step.txt 从来没有标题，因此您需要手动输入列，顺序应与前面代码中所示相同。
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，作为 main 函数的一部分，使用 run 变量连接到您的 AMLS 工作区，并设置一个用于数据存储的变量：
```
    ws = run.experiment.workspace
    datastore = Datastore.get_default(ws)
```
这是将保存您的最终输出文件的存储区。
在 Iris_Parallel_Output_Creation.py 的同一单元格中继续，作为 main 函数的一部分，使用 os 在您的计算集群上创建一个名为 Output_Folder 的文件夹，并编写一个名为 Iris_Parallel_Predictions.csv 的 CSV 文件：
```
    output_datastore_path = 'Output_Folder'
    os.makedirs(output_datastore_path, exist_ok=True) 
    FileName = "Iris_Parallel_Predictions.csv"
    OutputPath = os.path.join(output_datastore_path, FileName)
    result.to_csv(OutputPath, index = False, sep=',') 
```
即使原始的 parallel_run_step.txt 文件是空格分隔的，您也可以将最终输出文件的分隔符设置为所需的任何内容。
完成 Iris_Parallel_Output_Creation.py，将 Iris_Parallel_Predictions.csv 上传到名为 Output_Folder 的文件夹中，该文件夹位于您的数据存储中。

然后，使用 os 从您的计算集群中删除 Iris_Parallel_Predictions.csv 和 Output_Folder。最后，像在 创建机器学习管道 部分中那样触发您的 main 函数：
```
    datastore.upload_files(files=[OutputPath], target_path = output_datastore_path, overwrite=True)
    os.remove(OutputPath)
    os.rmdir(output_datastore_path)
if __name__ == '__main__':
    main()
```

在编写完这两个步骤后，其余的代码纯粹是为了容器化您的环境以及配置和运行您的管道。

配置和运行您的机器学习并行评分管道

由于您已经在“创建 ML 管道”部分中构建了您的环境，所以剩下的只是配置您的 ML 管道步骤。使用以下步骤：

在一个新的单元中，使用以下代码检索您在“创建 ML 管道”部分中创建的环境：
```
Env = Environment.get(ws, 'AutoML Environment') 
```
接下来，定义一个变量来定义您的管道数据并将其分配给数据存储：
```
parallel_run_output =\
PipelineData(name='parallel_predictions', datastore=datastore)
```
这是将在您的第一步和第二步之间保存parallel_run_step.txt的位置。您还必须给这个管道数据对象起一个名称。
在您的环境中启用 Docker，并将DEFAULT_CPU_IMAGE指定为您的ParallelRunStep的基础镜像：
```
parallel_environment = Env
parallel_environment.docker.enabled = True 
parallel_environment.docker.base_image = DEFAULT_CPU_IMAGE
```
您不需要为ParallelRunStep指定RunConfiguration对象。

为您的输出创建步骤创建一个RunConfiguration对象：

run_config = RunConfiguration()
run_config.environment = Env
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE

使用以下代码设置您的并行运行配置：
```
parallel_run_config = ParallelRunConfig(
    source_directory='Scoring_Scripts/',
    entry_script="Iris_Parallel_Scoring.py",
    mini_batch_size="1MB",
    error_threshold=5,
    output_action="append_row",
    environment=parallel_environment,
    compute_target=compute_target,
    run_invocation_timeout=60,
    node_count=4,
    logging_level="DEBUG") 
```
您需要输入 Python 脚本的名称以及包含它的源目录。您需要指定将并行评分的数据量，使用mini_batch_size。对于所有error_threshold是指步骤在管道失败之前可以并行失败多少次。接下来，将output_action设置为append_row将自动为您生成parallel_run_step.txt。其他output_action选项较为繁琐。

将您的计算目标设置为适当的计算集群并指定您的环境。将run_invocation_timeout设置为 60 秒，以便您的运行在空闲时间过长时将失败，并将node_count设置为您的计算集群中的节点数以确保最大并行化。最后，将logging_level设置为DEBUG以获取信息性日志。
设置您将需要创建并行评分步骤、数据集和模型名称的两个变量：
```
dataset = Dataset.get_by_name(ws,'Iris Parallel Scoring')
input_data =\
dataset.as_named_input('Iris_Parallel_Scoring')
model_name = 'Iris-Multi-Classification-AutoML'
```
数据集需要使用as_named_input代码传递，并在您的 Python 脚本中作为input_data变量出现。
使用以下代码创建您的并行评分步骤：
```
parallel_scoring_step = ParallelRunStep(
    name="iris-parallel-scoring-step",
    parallel_run_config=parallel_run_config,
    inputs=[input_data],
    output=parallel_run_output,
    arguments=['--model_name', model_name],
    allow_reuse=False) 
```
您需要给步骤起一个名称，iris-parallel-scoring-step。不允许有空格。使用parallel_run_config传递您的配置，并使用inputs传递您的数据集。将output设置为您的管道数据对象，并将模型名称作为参数传递。一如既往，将allow_reuse设置为False。
使用以下代码创建您的输出创建步骤：
```
output_step =\
 PythonScriptStep(name='iris-output-step',
script_name='Iris_Parallel_Output_Creation.py',
source_directory='Scoring_Scripts', 
arguments=\
["--input_data_folder", parallel_run_output,],
inputs=[parallel_run_output],
compute_target=compute_target,
runconfig=run_config,
allow_reuse=False)
```
给这个步骤起一个名称iris-output-step，并传递您的脚本名称和源目录。对于arguments和input，您需要传递parallel_run_output。这允许您的输出创建步骤使用由并行评分步骤生成的parallel_run_step.txt。然后，设置您的计算目标，指定您的运行配置，并将allow_reuse设置为False。

设置您的步骤序列并创建一个管道对象：

step_sequence =\
 StepSequence(steps=[parallel_scoring_step, output_step])
pipeline = Pipeline(workspace=ws, steps=step_sequence)

这次，您需要设置两个步骤，parallel_run_step和output_step。

给您的管道实验运行起一个名称，Iris-Parallel-Scoring-Pipeline-Run，并将其提交到您的计算集群：

pipeline_experiment = \
Experiment(ws, 'Iris-Parallel-Scoring-Pipeline-Run')
pipeline_run = \
pipeline_experiment.submit(pipeline, show_output=True)

使用RunDetails实时查看你的管道执行：
```
RunDetails(pipeline_run).show()
pipeline_run.wait_for_completion(show_output=True)
```
注意它如何快速评分你的数据。如果你的管道运行成功，它将以单词完成结束。你应该看到一个与图 9.6中相同的图形：

图 9.6 – 成功的并行管道运行图形
按照上一节的做法，将你的管道发布到端点，命名为Iris-Parallel-Scoring-Pipeline或你想要的任何名称：
```
published_pipeline = pipeline_run.publish_pipeline(
    name='Iris-Parallel-Scoring-Pipeline',\
    description='\
Pipeline that Scores Iris Data in Parallel', version= '1.0')
published_pipeline
```
运行此代码将给你发布管道的 ID 以及一个到端点的链接，如图图 9.7所示：

图 9.7 – 成功发布的并行管道

你现在可以像上一节那样检查和下载你的评分文件。在你的数据存储库中的Output_Folder内查找名为Iris_Parallel_Predictions.csv的文件。它比你的上一个文件大得多，大约 30MB。

在构建了标准评分管道和并行运行管道之后，你现在处于 AMLS 的前沿。这两个管道都可以用来评分不仅 AutoML 生成的 ML 模型，还可以自定义模型。

即使经验丰富的数据科学家也难以构建这些批量评分解决方案。因此，你已经掌握了一项有吸引力的、可销售的技能，这将使你能够与资深专家并肩工作。

在下一节中，你将学习如何构建用于训练 AutoML 模型的管道，而不是评分。

创建 AutoML 训练管道

有时，有必要重新训练你在 AutoML 中训练的模型。如果数据与目标变量之间的关系发生变化，ML 模型会随着时间的推移而退化。这对所有 ML 模型都适用，而不仅仅是 AutoML 生成的模型。

想象一下，例如，你构建了一个 ML 模型来预测超市冷冻披萨的需求，然后有一天，一家著名的披萨连锁店在隔壁开店。消费者购买行为很可能发生变化，你需要重新训练模型。这对所有 ML 模型都适用。

幸运的是，AMLS 有专门为重新训练模型构建的 ML 管道步骤。在本节中，我们将使用其中之一，即 AutoML 步骤。AutoML 步骤让你可以随时轻松地重新训练模型，无论是按按钮还是按计划。

在这里，你将构建一个两步机器学习（ML）管道，首先使用 AutoML 步骤训练一个模型，然后使用典型的 Python 脚本步骤注册它。这将使你能够构建具有自动化评分和训练的完整端到端解决方案，完善你的技能集。此外，这将使你熟悉 AutoML 步骤及其所有注意事项。

重要提示

并非所有 ML 模型都需要重新训练，尤其是那些预测物理现象的模型，因为你的数据与目标变量之间的关系不太可能随时间改变。然而，大多数 ML 模型会随着额外的数据点的增加而改进，因此随着你收集和标记更多数据，重新训练模型是有意义的。

到现在为止，你应该知道在创建 ML 管道方面可以期待什么。大多数步骤对你来说都很熟悉，但你将不得不与专门形式的管道数据一起工作，这些数据将数据从你的训练步骤传递到你的模型注册步骤。

此管道中涉及的 Python 脚本比评分管道中的脚本简单得多，因此当你尝试用你自己的数据时，需要更少的定制。在本节结束时，就像其他部分一样，你也将你的 AutoML 训练管道发布到端点。图 9.8概述了该过程：

图 9.8 – 设置 AutoML 重训练管道涉及的步骤

这个过程与其他管道略有不同，因为你需要尽早配置你的 AutoML 设置。你可以在 GitHub 仓库中的ML-Retraining-Pipeline.ipynb文件中找到所有步骤的代码。

编写你的 AutoML 训练管道的前两个步骤

要创建你的 AutoML 训练管道，请从以下步骤开始：

导航到你的计算实例上的 Jupyter 环境，创建一个新的 Jupyter 笔记本。命名为automl-training-pipeline。

打开你新创建的笔记本，并导入通常的 Azure 库以及AutoMLConfig：

from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment, Environment, Model
from azureml.core.compute import ComputeTarget
from azureml.train.automl import AutoMLConfig

AutoMLConfig允许你配置 AutoML 训练运行。

继续使用以下代码导入必要的 Azure ML 管道库：

from azureml.core.runconfig import RunConfiguration, CondaDependencies, DEFAULT_CPU_IMAGE
from azureml.pipeline.steps import PythonScriptStep, AutoMLStep
from azureml.pipeline.core import Pipeline, PublishedPipeline, PipelineData, TrainingOutput
from azureml.pipeline.core import StepSequence 
from azureml.widgets import RunDetails

有两个新的包。AutoMLStep是一个 ML 管道步骤，允许你运行 AutoML 训练运行。TrainingOutput允许你访问 AutoML 步骤的输出，以便传递到你的模型注册步骤。

导入os：
```
import os
```
这是构建此管道所需的唯一非 Azure Python 包，它将被用来创建一个新的文件夹。
将你的 Jupyter 笔记本连接到你的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果需要，按照说明登录。

设置你的计算集群：

compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)

设置你的数据存储：
```
datastore = Datastore.get_default(ws)
```
使用以下代码检索你的Iris Training数据集。你将此数据集传递到你的 AutoML 配置设置中：
```
dataset = Dataset.get_by_name(ws, 'Iris Training')
```
获取你在本章创建 ML 管道部分创建的名为AutoML Environment的环境：
```
Env = Environment.get(ws,'AutoML Environment') 
```

这将仅用于你的模型注册步骤；你的 AutoML 训练步骤将使用标准、自动生成的环境。

配置你的 AutoML 模型训练设置和步骤

接下来，你将使用以下代码配置与你的 AutoML 训练步骤相关的所有设置：

设置变量以传递到你的 AutoML 配置设置中：
```
target_column = 'species'
task = 'classification'
primary_metric = 'accuracy'
featurization = 'auto'
num_classes = 3
iterations = 4
```
这些设置的说明可以在第五章中找到，构建 AutoML 分类解决方案。一个新设置是 iterations。这将用于确定应该并行训练多少个 AutoML 模型；此值应等于您的计算集群上的节点数，以确保最大并行化。

配置您的 AutoML 训练运行：

config = AutoMLConfig(task=task,
                     primary_metric=primary_metric,
                     num_classes=num_classes,
                     featurization=featurization,
                     compute_target=compute_target,
                     training_data=dataset,
                     label_column_name=target_column,
                     experiment_timeout_minutes=15,
                     enable_early_stopping=True,
                     max_concurrent_iterations = iterations,
                     n_cross_validations=5,
                     model_explainability=True,
                     enable_stack_ensemble=True,
                     enable_voting_ensemble=True)

这些设置的说明可以在第四章中找到，构建 AutoML 回归解决方案。如果您希望获得更高的精度，请调整 experiment_timeout_minutes 以给 AutoML 更多时间进行训练。请注意，您在这里传递了您的数据集。

设置 AutoML 指标输出：
```
metrics_data =PipelineData(name='metrics_data',\
 datastore=datastore,pipeline_output_name='metrics output',\
       training_output=TrainingOutput(type='Metrics'))
```
此代码是每个 AutoML 步骤中使用的标准样板代码。它将您的 AutoML 运行中的指标保存为中间管道数据，您可以使用这些数据传递到您的 ML 管道中的其他步骤。
设置您最佳模型的输出：
```
model_data = PipelineData(\
name='model_data', datastore=datastore, pipeline_output_name='best_model_output',\
         training_output=TrainingOutput(type='Model'))
```
此代码是每个 AutoML 步骤中使用的标准样板代码。它将您的 AutoML 运行中关于最佳模型的信息保存为中间管道数据，以便传递到您的模型注册步骤。

配置您的 AutoML 步骤：

automl_training_step = AutoMLStep(
    name='Multiclass_AutoML_Step',
    automl_config=config,
    outputs=[metrics_data, model_data],
    allow_reuse=False)

您需要做的只是给它一个名称，传递您的 AutoML 配置设置，并指定 metrics_data 和 model_data 作为输出。始终将 allow_reuse 设置为 False。

创建一个 Python 脚本以注册您的模型

在配置了 AutoML 训练步骤后，您现在需要编写另一个脚本，使用以下步骤提取和注册您的模型：

使用 os 创建一个文件夹来保存您的训练脚本：
```
os.makedirs('Training_Scripts', exist_ok=True)  
```
编写一个 Python 脚本以注册您的模型。与您编写的其他脚本相比，此脚本非常简短。首先，使用 %%writefile 魔法命令编写一个新的 Python 脚本文件，名为 Iris_Model_Registration.py，并加载您的 Azure 库和 argparse：
```
%%writefile Training_Scripts/Iris_Model_Registration.py
from azureml.core import Run, Workspace, Model
from azureml.core import Dataset, Datastore
import argparse
```
在 Iris_Model_Registration_Scoring.py 的同一单元格中继续，使用 Run 函数设置一个名为 run 的变量：
```
run = Run.get_context()
```
在 Iris_Model_Registration_Scoring.py 的同一单元格中继续，传递您的参数以访问由 AutoML 训练的最佳模型以及您用于训练模型的数据库。为此，您需要三个参数，model_name、model_path 和 dataset_name：
```
parser = argparse.ArgumentParser()
parser.add_argument("--model_name", dest="model_name")
parser.add_argument("--model_path", dest="model_path")
parser.add_argument("--dataset_name", dest="dataset_name")
args = parser.parse_args() 
```
在 Iris_Model_Registration_Scoring.py 的同一单元格中继续，编写一个名为 main 的函数。此函数将注册您的最佳模型。首先，使用 run 变量连接到您的 AMLS 工作区：
```
def main():  
    ws = run.experiment.workspace 
```
在 Iris_Model_Registration_Scoring.py 的同一单元格中继续，作为 main 函数的一部分，通过 dataset_name 参数检索您的数据集：
```
    ds = Dataset.get_by_name(ws, args.dataset_name)
    dataset = [(Dataset.Scenario.TRAINING, ds)] 
```
使用 Dataset.Scenario.Training 代码行指定它所使用的场景。当您注册模型时，将保存此信息。

在Iris_Model_Registration_Scoring.py的同一单元格中，作为main函数的一部分，使用model_path和model_name参数注册您的模型：

    model = Model.register(workspace=ws,
                           model_path=args.model_path,
                           model_name=args.model_name,
                           datasets=dataset)
if __name__ == '__main__':
    main()

虽然model_name是您指定的，但model_path将自动从model_data生成。您用于训练模型的那个数据集也将使用此代码保存。最后，使用触发main的样板代码完成Iris_Model_Registration_Scoring.py。

配置和运行您的 AutoML 训练管道

剩下的就是容器化您的环境，配置您的模型注册步骤，并按照以下步骤运行和发布您的管道：

为模型注册步骤创建一个RunConfiguration对象：
```
run_config = RunConfiguration()
run_config.environment = Env
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE
```
注意，这使用的是AutoML 环境，但如果您愿意，也可以使用没有pandas或 NumPy 的更简单环境。
设置模型名称和数据集名称的变量：
```
model_name = 'Iris-Multi-Classification-AutoML'
dataset_name = 'Iris Training'
```
您的模型名称将用于注册 AutoML 生成的最佳模型，这是您的选择。另一方面，您的数据集名称应该与您用于训练模型的那个数据集相匹配。

配置您的模型注册步骤：

model_registration_step = \
PythonScriptStep(script_name="Iris_Model_Registration.py",\
               source_directory = 'Training_Scripts',\
               name = "Model-Registration-Step",\
               allow_reuse = False,\
               arguments = ["model_name",model_name,\
 "--model_path", model_data, "--dataset_name",\
 dataset_name],\
               inputs = [model_data],\
               compute_target = compute_target,\
               runconfig = run_config,\
               allow_reuse = False)

在这里，您必须传递三个参数，model_name、model_data和dataset_name，并将model_data作为输入传递。这是因为model_data是您的 AutoML 训练步骤生成的管道数据，而model_name和dataset_name是简单的字符串变量。一如既往，将allow_reuse设置为False。

设置您的步骤序列并创建一个管道对象：
```
step_sequence =\
StepSequence(steps=[parallel_scoring_step, output_step])
pipeline = Pipeline(workspace=ws, steps=step_sequence)
```
这次，您需要设置两个步骤，automl_training 步骤和model_registration 步骤。
给您的管道实验运行起一个名字，Iris-AutoML-Training-Pipeline-Run，并将其提交到您的计算集群：
```
pipeline_experiment =\
Experiment(ws, 'Iris-Parallel-Scoring-Pipeline-Run')
pipeline_run =\
pipeline_experiment.submit(pipeline, show_output=True)
```
这将比您的其他管道花费更长的时间，可能大约半小时。
使用RunDetails实时查看您的管道执行：
```
RunDetails(pipeline_run).show()
pipeline_run.wait_for_completion(show_output=True)
```
如果您的管道运行成功，它将以“完成”一词结束。您应该看到一个与图 9.9 中相同的图形：

图 9.9 – 成功的 AutoML 训练管道
按照上一节中的方法将管道发布到端点，命名为Iris-AutoML-Training-Pipeline或您想要的任何名称：
```
published_pipeline = pipeline_run.publish_pipeline(
    name='Iris-AutoML-Training-Pipeline',\
    description=\
'Pipeline that Trains Iris Data with AutoML', version= '1.0')
published_pipeline
```
运行此代码将为您提供已发布的管道 ID 以及访问端点的链接，如图 9.10 所示：

图 9.10 – 成功发布的 AutoML 训练管道

重要提示

有时当您运行一个机器学习管道时，您的计算机可能会崩溃。然而，您的管道运行将继续进行，并且您仍然可以在完成后发布它。要检索一个已完成的管道以便发布，请使用以下代码：

from azureml.pipeline.core import PipelineRun
experiment = Experiment(ws, 'your-experiment_name')
pipeline_run = PipelineRun(experiment, 'your-pipeline-run-id')

你现在已经构建了三个机器学习管道，一个标准评分管道、一个并行运行管道和一个 AutoML 训练管道。这并非易事，但所有的辛勤工作都得到了回报。你已经掌握了 AMLS 中最复杂的一部分。

虽然创建这些管道是一项相当艰巨的任务，但一旦拥有它们，它们就非常容易手动重新运行或自动调度，正如你将在下一节中看到的那样。

触发和调度你的机器学习管道

数据科学家面临的最大问题之一是创建易于重用、生产就绪的代码，并以自动、可靠的方式对其进行调度。你已经通过创建三个机器学习管道完成了第一部分。现在，是时候学习如何完成第二部分了。

在本节中，你将首先学习如何通过图形用户界面手动触发你创建的管道。然后，你将学习如何通过代码触发管道，包括手动和自动调度。这将使你能够将你的机器学习管道投入生产，每小时、每天、每周或每月生成结果。

从 GUI 触发已发布的管道

从 AML 工作室 GUI 触发已发布的管道很容易。然而，目前你无法为你的机器学习管道设置自动调度。因此，它最有用的情况是在你注意到结果似乎不正确时触发训练管道。使用以下步骤通过 AML 工作室手动触发你的机器学习管道：

导航到ml.azure.com以访问 AML 工作室。
点击左侧资产下的管道。
点击页面顶部附近的管道端点。
点击蓝色链接Iris-AutoML-Training-Pipeline。
点击提交。这将打开一个对话框。
从Iris-AutoML-Training-Pipeline-Run下的下拉框中选择一个实验名称。
点击提交。
再次点击资产下的管道，在顶部行，你应该看到一个新运行，如图9.11所示：

图 9.11 – 通过 GUI 提交的管道运行

与创建机器学习管道相比，重新提交它非常简单。接下来，我们将探讨通过代码触发我们的管道并创建自动调度的方法。

通过代码触发和调度已发布的管道

通过代码首先触发已发布的机器学习管道需要你获取你的管道 ID。这些在上一节的末尾生成，每次你发布一个管道时都会生成。你还可以通过点击 AML 工作室下管道端点中的单个管道来找到你的管道 ID。你还需要你的管道 ID 来通过代码设置调度。

本节中所有代码都可以在 GitHub 仓库中的ML-Pipeline-Scheduling.ipynb文件中找到。首先，打开一个 Jupyter 笔记本并按照以下步骤操作：

如同之前一样创建一个新的 Jupyter 笔记本。将其命名为pipeline-scheduling。

打开你的笔记本并导入所需的 Azure 库，其中三个是新的。PublishedPipeline让你可以访问你发布的任何 ML 管道。Schedule和ScheduleRecurrence让你可以安排 ML 管道：

from azureml.core import Workspace, Datastore
from azureml.pipeline.core import Pipeline, PublishedPipeline
from azureml.core.experiment import Experiment
from azureml.pipeline.core.schedule import ScheduleRecurrence, Schedule

要手动触发一个 ML 管道，使用以下代码，并用你发布的 AutoML 训练管道的 ID 替换your-published-pipeline-id。就是这样：

experiment =\
Experiment(ws,'AutoML-Retraining-Code-Trigger')
published_pipeline =\
PublishedPipeline.get(workspace=ws, id='your-published-pipeline-id')
pipeline_run = experiment.submit(published_pipeline)

要创建运行你的 ML 管道的日程安排，首先使用以下代码确定一个间隔。间隔选项有Minute（分钟）、Hour（小时）、Day（天）、Week（周）或Month（月）。你也可以指定start_time（开始时间）和time_zone（时区）作为可选参数。另一个可选参数是status（状态），你可以将其设置为Disabled来关闭你的日程安排：
```
recurrence =\
ScheduleRecurrence(frequency="Day", interval=1)
```

通过提供一个名称并传递你的recurrence设置、实验名称、发布的管道 ID 和描述来创建你的日程安排：

schedule = \
Schedule.create(ws, name="IrisTrainingSchedule", 
                       description="AutoML Training",
                       pipeline_id='your-pipeline-id', 
                       experiment_name='Iris-Retraining', 
                       recurrence=recurrence)

你现在已经创建了一个日程安排，该安排将每天自动触发你的 AutoML 训练管道。这个日程安排将自动启动你的计算集群，训练一个模型，然后关闭。许多公司花费数年时间试图找出如何及时、可靠地安排 ML 训练和评分运行的最佳方法，而你仅用了一章就完成了这个任务！

摘要

你现在已经实现了一个使用 AutoML 训练模型的全自动 ML 批量评分解决方案。你已经创建了可以评分模型的管道，可以并行处理大数据的管道，以及可以重新训练 AutoML 模型的管道。你可以随时触发它们，甚至可以设置自动评分日程。这可不是一件小事，因为许多组织花费了数年时间去学习这些任务的最佳实践。

在第十章《创建端到端 AutoML 解决方案》中，你将在学习如何将数据导入 Azure、使用 ML 管道进行评分以及将结果写入你想要的任何位置的过程中巩固你的知识。

第十章：创建端到端 AutoML 解决方案

现在你已经创建了机器学习（ML）管道，你可以学习如何在 Azure 的其他产品中使用它们，而不仅仅是 Azure Machine Learning Service（AMLS）。最有用的是 Azure Data Factory。

Azure Data Factory（ADF）是 Azure 首选的无代码数据编排工具。你可以使用 ADF 从本地源提取数据到 Azure 云中，运行机器学习管道，并通过创建 Azure Data Factory pipeline（ADF 管道）将数据推离 Azure。ADF 管道是创建端到端机器学习解决方案的必要组成部分，也是任何非实时 AutoML 项目的最终目标。

你将从这个章节开始学习如何将 AMLS 连接到 ADF。一旦你完成了这个任务，你将学习如何使用你在 第九章 中创建的并行管道来安排一个机器学习管道，该章节名为 实现批量评分解决方案。

接下来，你将学习如何使用 ADF 从你的本地机器中提取数据并将其加载到 Azure 云中。最后，你将把所有东西整合起来，创建一个端到端的 AutoML 解决方案，创建一个用于评分传入数据的 ADF 管道，以及另一个用于重新训练 AutoML 模型的 ADF 管道。

到本章结束时，你将能够将 AMLS 与 ADF 集成以创建 ADF 管道，并能够设计完整的端到端 AutoML 解决方案，从数据摄取和评分到机器学习模型的重新训练。这是一套无价且需求旺盛的技能，将使你与你的同行区别开来。

如果你已经是一名训练有素的数据科学家，你将获得你领域内罕见的软件工程技能。如果你是一名训练有素的工程师，你将学习如何将机器学习融入你已熟悉的领域。

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

将 AMLS 连接到 ADF
在 ADF 中安排机器学习管道
使用 ADF 转移数据
自动化端到端评分解决方案
自动化端到端训练解决方案

技术要求

在本章中，你将创建一个 ADF 资源，并使用你在 第九章 中创建的机器学习管道对象，该章节名为 实现批量评分解决方案。因此，你需要一个有效的互联网连接、一个 Azure 账户以及访问你的 AMLS 工作空间。

使用你的 Azure 账户，你还需要在 Azure Active Directory 中创建服务主体的权限。如果你使用的是个人 Azure 账户，你应该有这种访问权限。如果你使用的是工作账户，你应该与你的 Azure 管理员联系以获得这种级别的权限。

本章的先决条件如下：

有互联网访问权限
拥有一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium
拥有 Microsoft Azure 账户
已创建 AMLS 工作空间
已在第二章“Azure 机器学习服务入门”中创建了compute-cluster计算集群。
了解如何从 Azure 计算实例导航到 Jupyter 环境，如第四章“构建 AutoML 回归解决方案”中所示。
已在第五章“构建 AutoML 分类解决方案”中训练并注册了Iris-Multi-Classification-AutoML机器学习模型。
已在第九章“实现批量评分解决方案”中创建了所有三个机器学习管道。这三个机器学习管道是Iris-Scoring-Pipeline、Iris-Parallel-Scoring-Pipeline和Iris-AutoML-Training-Pipeline。
在 Azure Active Directory 中拥有创建服务主体的必要权限。如果你使用的是个人账户，你将拥有这些权限。

本章的代码在此处可用：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/tree/master/Chapter10。

将 AMLS 连接到 ADF

ADF 是一个无需编写代码的数据编排和转换工具。使用它，你可以创建可以将数据复制到 Azure、转换数据、运行机器学习管道并将数据推回到某些本地数据库和文件共享的 ADF 管道。使用 ADF 的无需编写代码的管道编辑工具创建和安排 ADF 管道非常简单。当你使用拖放界面创建 ADF 管道时，你实际上是在编写 JSON 代码，这是 ADF 用于执行作业的代码。

小贴士

Azure Synapse Analytics，微软 Azure 的顶级数据仓库和集成分析服务，也具有与 ADF 管道几乎相同的特性：Azure Synapse 管道。本章中用 ADF 管道所做的任何事情，都可以使用非常相似的界面通过 Azure Synapse 管道实现。

在本节中，你将创建一个 ADF 资源并将其连接到 AMLS。你将使用链接服务来完成此操作，这是一个类似于 ADF 连接到其他 Azure 和非 Azure 服务和数据存储所需的连接字符串的对象。链接服务需要身份验证，而 AMLS 需要服务主体身份验证。

服务主体是 Azure 用于在 Azure 资源之间授予权限的安全标识符。一旦你授予你的服务主体对 ADF 和 AMLS 的访问权限，连接它们并开始运行机器学习管道就变得很容易了。

创建 ADF

ADF 可以通过 GUI 或使用你在 第二章，Azure 机器学习服务入门 中使用的 Azure 命令行界面（CLI）通过 PowerShell 创建。PowerShell 是一系列用于通过 CLI 管理 Azure 资源的 cmdlet。在这里，你将首先学习如何使用 Azure 门户 GUI 创建 ADF 资源。然后，你将学习如何通过 PowerShell 创建 ADF 资源。

要使用 GUI 创建 ADF 资源，请执行以下操作：

导航到 Azure 门户 portal.azure.com。
点击左上角的 创建资源。
在搜索框中输入 数据工厂 并从下拉框中选择 数据工厂。
点击创建，位于 数据工厂 顶部左角的蓝色框。
现在填写 数据工厂创建 表单。首先选择包含你的 AMLS 工作区的相同 资源组。如果你在 第二章，Azure 机器学习服务入门 中使用了建议的 资源组，这将是指 auto-ml-example-resource-group。
选择包含你的 AMLS 工作区的相同 Azure 区域。如果你在 第二章，Azure 机器学习服务入门 中使用了建议的 Azure 区域，这将是指 北中 US。
在 automl-adf 中给你的 ADF 起一个名字，后面跟着一个数字字符串。以下截图显示了你的完成设置应该看起来像什么。将版本保持为 V2：

图 10.1 – 数据工厂设置
点击 Git 配置 选项卡并勾选 稍后配置 Git 复选框。
点击 审阅 + 创建 并点击创建。你的数据工厂现在已创建。

创建 ADF 资源的另一种方式是通过 PowerShell。按照以下步骤操作：

导航到 Azure 门户 portal.azure.com。
点击屏幕右上角的计算机屏幕图标，如图所示。当你悬停在图标上时，会出现 Cloud Shell 的文字：

图 10.2 – 导航到 PowerShell
从下拉框中选择 PowerShell。
输入以下代码：
```
$DataFactory =\
Set-AzDataFactoryV2 -ResourceGroupName 'auto-ml-example-resource-group' -location 'northcentralus' -Name 'automl-adf713'
```
ResourceGroupName 设置你的资源组。Set-AzDataFactoryV2 设置你的版本，而 location 设置你的 Azure 区域。Name 给你的 ADF 起一个名字。你的数据工厂现在已创建。

现在你已经创建了一个 ADF，下一步是创建一个服务主体，并给它访问你的 ADF 和 AMLS 工作区的权限。这将授予 ADF 使用 ML 管道的权限。

创建服务主体并授权访问

服务主体是 Azure 用来授予 Azure 资源访问其他 Azure 资源的安全标识符。你可以在 Azure 的许多区域使用服务主体身份验证，包括 AMLS。然而，为了将 AMLS 连接到 ADF，需要一个服务主体。要使用 Azure 门户创建一个，你必须首先按照以下步骤导航到Azure Active Directory，Azure 的顶级身份和认证服务：

导航到 Azure 门户，网址为portal.azure.com。
在顶部搜索栏中搜索Azure Active Directory，然后在服务标题下点击Azure Active Directory。
点击屏幕左侧的应用程序注册。
点击屏幕左上角的新建注册。
给服务主体起一个名字，adf-service-principal，然后点击注册。保留所有其他设置不变。
你现在将被带到包含你的服务主体所有信息的页面。复制应用程序（客户端）ID，并将其粘贴到记事本或类似的文本编辑器中。你稍后需要这个 ID。
点击屏幕左侧的证书和秘密。这将允许你为你的服务主体创建一个密码。
点击新建客户端秘密。"秘密"在 Azure 中是密码的另一种说法。
给秘密起一个名字，ADF-Secret，并设置它永远不会过期，如图 10.3所示。点击添加：

图 10.3 – 命名你的服务主体秘密
复制你的秘密的值字段。这是你的密码，你只能在它消失之前短暂地看到它。一旦它消失，你就再也无法看到它了。将它粘贴到记事本或类似的文本编辑器中，因为你稍后创建你的 ADF 链接服务时需要它。
你的服务主体创建后，你必须现在授予它对 AMLS 和 ADF 的访问权限。导航到 Azure 门户的前页，网址为portal.azure.com。
通过点击屏幕上Azure 服务部分靠近顶部的机器学习图标来打开你的 AMLS 资源。如果你最近使用过 AMLS，你应该能看到它，如图 10.4所示：

图 10.4 – Azure 服务面板
点击你的 AMLS 工作区的名称以访问资源。
点击左侧面板上的访问控制（IAM）。
点击添加角色分配。
选择adf-service-principal，如图 10.5所示点击它。然后，点击保存：

图 10.5 – 授予你的服务主体权限
你现在已经授予你的服务主体对 AMLS 的访问权限。现在，你必须为 ADF 做同样的事情。首先，通过点击屏幕左上角的主页，导航到 Azure 门户的前页。
在屏幕顶部的Azure 服务下点击数据工厂图标。如果您最近使用过 ADF，您将看到此图标。
点击您创建的数据工厂的名称以打开资源。
对 ADF 重复步骤 14-16。这些步骤与 AMLS 相同。现在您已授予服务主体对 ADF 和 AMLS 的访问权限。

通过 Azure CLI 创建 ADF 资源

您还可以通过以下步骤在 Azure CLI 中创建服务主体并授予其对 ADF 和 AMLS 的访问权限：

通过点击屏幕右上角的计算机屏幕图标打开 Azure CLI，然后从下拉菜单中选择Bash。
输入以下代码以创建您的服务主体，并为其分配一个名称：
```
az ad sp create-for-rbac --name adf-service-principal
```
复制appid和password字段。您将再也看不到密码的值，所以请确保复制它。这对应于应用程序（客户端）ID和密钥。
使用以下代码授予您的服务主体对包含 AMLS 和 ADF 的资源组中所有资源的访问权限。如有必要，请将其更改为匹配您的资源组。使用assignee传入您的服务主体应用程序 ID。使用role传入正确的访问级别，在这种情况下，使用resource-group将访问权限分配给正确的资源组：
```
az role assignment create --assignee "your-service-principal-id" --role "Contributor" --resource-group "auto-ml-example-resource-group"
```

在创建服务主体并授予适当的资源访问权限后，您的下一步是打开 ADF 并创建链接服务。请确保您打开了记事本，因为您将需要服务主体 ID 以及您创建的密钥。这些信息随时可用将使下一步变得容易。

创建一个链接服务以连接 ADF 和 AMLS

从现在开始，您将有机会打开 ADF 并熟悉其界面。ADF 主要设计为一个无代码平台，但您创建的每一项内容都在底层以 JSON 文件的形式编写。要连接 ADF 和 AMLS，请按照以下步骤操作：

导航到 Azure 门户 portal.azure.com。
在屏幕顶部的Azure 服务下点击数据工厂图标。如果您最近使用过 ADF，您将看到此图标。如果没有，请使用屏幕顶部的搜索栏。
点击以autol-adf开头的您创建的数据工厂的名称。
在屏幕中间点击作者和监控。现在您应该看到 ADF 用户界面，如图 10.6 所示：

图 10.6 – ADF UI
在左侧点击工具箱图标。当您将鼠标悬停在图标上几秒钟时，会出现单词管理，表示您正在导航到的部分。
在屏幕左上角的连接下点击链接服务。
点击创建链接服务。
点击计算并选择如图 10.7 所示的Azure 机器学习：

图 10.7 – 创建 Azure ML 链接服务
点击继续。
现在是填写链接服务创建表单的时候了。首先，给您的链接服务起一个名称，例如AMLS 链接服务。
从通过集成运行时连接下的下拉菜单中选择AutoResolveIntegrationRuntime。集成运行时是 ADF 在底层用于移动数据和运行作业的计算。Azure 集成运行时（Azure IR）是一种由 ADF 完全管理的无服务器、弹性计算。
从Azure 订阅下的下拉框中选择您的 Azure 订阅。
从Azure 机器学习工作区名称下的下拉框中选择您的 AMLS 工作区。
将您的服务主体应用程序（客户端）ID 粘贴到服务主体 ID文本框中。您之前已将此 ID 复制到文本编辑器中。
将您的服务主体密钥粘贴到服务主体密钥文本框中。
点击测试连接。
如果测试结果为连接成功，则点击创建。
您的链接服务已创建。将鼠标悬停在您的新链接服务上并点击{ }图标以查看底层的 JSON 代码。

您已成功将 ADF 连接到 AMLS。在本节中，您学到了很多。您不仅学会了如何创建 ADF，还学会了如何创建服务主体、授权访问和创建链接服务。有了这个基础设施，您现在可以学习如何在 ADF 管道中轻松运行和安排 ML 管道。

在 ADF 中安排机器学习管道

也许 ADF 的最佳特性是其易用性。通过在屏幕上点击并拖动对象，您可以通过 ADF 管道轻松编排无缝的数据摄取、转换和机器学习流程。此外，通过几点击，您还可以安排 ADF 管道在您想要的时间运行。掌握这项技能将使您能够快速轻松地创建无代码的数据编排运行。

首先，您将安排并运行您在第九章，“实现批量评分解决方案”中创建的最简单的 ML 管道，即 Iris-Scoring-Pipeline。为此，请按照以下步骤操作：

导航到您的 ADF 资源并点击作者与监控。
在左侧点击笔形图标。当您将鼠标悬停在此图标上时，将显示文字作者，指示您正在导航到的部分。
在屏幕左上角的工厂资源下方的搜索框旁边的蓝色十字图标处点击。当您将鼠标悬停在此图标上时，将显示文字添加新资源。
如图 10.8所示，从结果下拉菜单中点击管道：

图 10.8 – 创建您的第一个 ADF 管道
在屏幕中心左方的活动下点击机器学习。
按照图 10.9 所示，将蓝色烧瓶图标拖放到画布上。这是机器学习执行管道活动：

图 10.9 – 机器学习执行管道活动
点击执行 Iris Scoring Pipeline。
在画布下方点击设置。
从第一个下拉菜单中选择AMLS Linked Service以连接您的链接服务。
从机器学习管道名称下拉菜单中选择Iris-Scoring-Pipeline。
从机器学习管道 ID下拉菜单中选择一个管道 ID。除非您发布了多个具有相同名称的 ML 管道，否则应该只有一个管道 ID。
点击右上角的算盘图标以打开从pipeline1到Iris Scoring Pipeline的pipeline。允许使用空格。
在屏幕右上角附近点击全部发布。然后，点击屏幕右下角的发布以创建您的 ADF 管道。

重要提示

为了在 ADF 中保存您的作品，您需要发布您的更改。确保在开发新的 ADF 管道时多次发布。
要安排您新创建的 ADF 管道，请点击屏幕顶部的添加触发器。
点击结果下拉菜单中的新建/编辑。
点击选择触发器下拉菜单并选择新建。

与 AML Python SDK 一样，ADF 中有多种类型的触发器。在时间表上执行基于调度的触发器。当在 Azure blob 容器中创建或删除文件时执行基于事件的触发器。

滚动窗口触发器类似于基于调度的触发器，但它们更高级，具有诸如重试失败的运行和回填过去时间段等选项。对于这个练习，创建一个简单的基于调度的触发器。
给您的触发器起一个名字，例如每月一次。
在类型下选择调度。
从相应的下拉菜单中选择一个开始日期和适当的时间区域。
在1下选择从下拉菜单中的月份。
点击两次确定。
在屏幕右上角附近点击全部发布，然后点击屏幕右下角的发布。现在您已经完成。您的完成 ADF 管道应该看起来像图 10.10。要查看 JSON 代码，请点击屏幕右上角的{ }图标：

图 10.10 – 您的第一个完成的 ADF 管道

虽然您已创建并安排了第一个 ADF 管道，但这并不意味着什么。毕竟，尽管这个 ADF 管道将每月触发您的 ML 管道，但您仍然需要自动化新数据的摄入。幸运的是，ADF 在数据摄入方面表现出色。您将在下一节中看到使用 ADF 转移数据是多么简单。无论数据在哪里，ADF 都可以将其拉入。

使用 ADF 转移数据

从本地到云以及从云到本地的数据迁移是任何数据工程师或数据科学家的一项关键技能。ADF 通过复制数据活动完成这项任务。这是 ADF 最基本也是最有力的功能。

在本节中，首先，您将下载一个自托管集成运行时（SHIR）到您的本地机器，使您的计算机能够作为计算资源将数据加载到 Azure。然后，您将为您的Azure 存储帐户和您的本地 PC 创建一个链接服务。

接下来，您将从 GitHub 仓库下载一个文件并将其保存到您的 PC 上。最后，您将在 ADF 中创建一个复制数据活动，该活动将从您的 PC 中提取数据并将其放入与 AML 数据存储连接的同一 Azure blob 容器中。

完成这些练习将为你提供数据工程技能，这将使你能够在下一节创建端到端解决方案。

安装自托管集成运行时

在您可以将数据复制到 Azure 之前，您首先需要在您的本地机器上安装一个 SHIR。以下步骤开始：

导航到您的 ADF 资源并点击作者和监控。
点击左侧的工具箱图标。当您将鼠标悬停在此图标上时，将出现单词管理，以指示您正在导航到的部分。
在连接下点击集成运行时。
在屏幕顶部中心点击新建。
选择Azure, Self-Hosted并点击继续，如图 10.11 所示：

图 10.11 – 选择正确的集成运行时安装 SHIR
选择自托管并点击继续。
给您的新 SHIR 起个名字，IntegrationRuntime，并点击创建。
在下一屏幕上，您将看到两个安装 SHIR 的选项。通过点击点击此处启动此计算机的快速设置选择选项 1：快速设置。

重要提示

如果您正在使用工作机器，在安装 SHIR 之前请向您的 IT 安全组织请求许可。它确实会在您的机器和面向公众的 Azure 云之间建立连接。
这将下载 SHIR 安装文件到您的计算设备。打开文件并点击是。安装应需时 5 到 10 分钟。
安装完成后，点击关闭。您的 SHIR 现在应如图 10.12 所示：

图 10.12 – 自托管集成运行时

在您的本地机器上安装了 SHIR 后，您现在可以使用 ADF 直接将数据从您的 PC 移动到 Azure。就像您为 AMLS 创建了链接服务一样，接下来您将为 Azure Blob 存储创建一个链接服务。

创建 Azure Blob 存储链接服务

要创建一个连接 ADF 到Azure Blob 存储的链接服务，请按照以下步骤操作：

在屏幕左上角的连接下的 链接服务 上点击。
在屏幕顶部中央点击 +新建。
选择 Azure Blob Storage 并点击继续以查看链接服务创建表单。
给你的链接服务起一个像 AMLSDatastoreLink 这样的名字。
选择 AutoResolveIntegrationRuntime。
从 Azure 订阅 下的下拉框中选择你的 Azure 订阅。
在 automlexamplew 后跟一串数字的下拉框中选择你的存储账户。
点击 测试连接。
如果你的测试成功，点击创建。
从 GitHub 仓库下载 Iris_Scoring_Data_for_ADF.csv：

github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Chapter10/Iris_Scoring_Data_for_ADF.csv
在你的 PC 上创建一个名为 Iris 的文件夹。将 Iris_Scoring_Data_for_ADF.csv 移动到那里。

创建一个连接到你的 PC 的链接服务

接下来，是时候创建一个连接到你的 PC 的链接服务了。这个链接服务将使用你的 SHIR。按照以下步骤操作：

点击 链接服务 和 +新建，就像创建其他链接服务一样。
点击文件，选择 文件系统，并点击继续以查看链接服务创建表单。
给你的链接服务起一个像 LocalPCLink 这样的名字。
从 通过集成运行时连接 下的下拉框中选择你的 SHIR。
在 Iris 文件夹下。
填写用于登录你的 PC 的用户名和密码。要找到你的用户名，在你的 PC 的搜索栏中搜索 系统信息 并点击它；你的用户名可以在 系统摘要 下找到。
点击 测试连接。
如果测试成功，点击创建。

创建一个用于复制数据的 ADF 管道

使用 SHIR、Azure Blob 存储链接服务和连接到本地 PC 的链接服务，你现在可以使用以下步骤使用 复制数据 活动构建 ADF 管道：

在 ADF 的左侧点击笔形图标。
在屏幕左上角的 工厂资源 旁边的搜索框旁边点击蓝色十字图标。当鼠标悬停在此图标上时，会显示文字 添加新资源。
如 图 10.13 所示，从结果下拉菜单中点击 复制数据工具：

图 10.13 – 复制数据工具
在 Copy Iris Data to Azure 下点击 下一步。
你现在必须选择你的源数据存储。选择连接到你的 PC 的链接服务，LocalPCLink，并点击 下一步。
通过点击 Iris_Scoring_Data_for_ADF.csv 并点击选择来选择你希望传输到 Azure 的数据。
点击 下一步。
在 文件格式设置 下，勾选 第一行作为标题 并点击 下一步。
您现在必须选择您的目标数据存储库。选择连接到 Azure 存储账户的链接服务，AMLSDatastoreLink。
在Input_Folder/Iris_Scoring_Data.csv下，点击文件夹Input_Folder中的Iris_Scoring_Data.csv。如果不存在，文件夹将被创建。
在文件格式设置下，勾选添加标题到文件并点击下一步。
在设置下点击下一步，不要更改任何默认设置。
在摘要下点击下一步。您的 ADF 管道现在将被创建并运行。
点击完成。您现在将被带到 ADF 管道的主要创作工具。
在管道下点击将 Iris 数据复制到 Azure。您会注意到您的复制数据活动命名不佳。
点击您的活动并将其重命名为从 PC 复制 Iris 数据，如图图 10.14所示：

图 10.14 – 包含复制数据活动的完成 ADF 管道
通过点击全部发布然后发布来保存对管道的更改。

您现在已成功使用 ADF 将数据从您的 PC 传输到 Azure。这是数据工程的基础技能，允许您将各种数据传输到云端。就像您在上一节中创建的 ADF 管道来执行 ML 管道一样，您可以安排它在任何您希望的时间表上运行。

我们现在将结合本章中学到的所有技能，编写一个真正可生产的 ADF 管道。此管道将从您的计算机中摄取数据，评分数据，然后将结果写回到您的本地机器。尽管这不是一项微不足道的任务，但您将在本章结束时能够连续生成管道。

自动化端到端评分解决方案

任何 AutoML 项目的最终目标都是创建一个自动评分解决方案。数据从源中提取，使用您训练的模型自动评分，并将结果存储在您选择的位置。通过结合您在前三个部分中学到的所有内容，您可以轻松完成这项任务。

您将开始本节，通过打开 AMLS，创建一个新的数据集，并稍微修改您现有的Iris-Scoring-Pipeline。然后，在以新名称重新发布您的管道后，您将将其与您创建的复制数据活动结合起来，以便将数据加载到 Azure 中。

接下来，您将创建另一个复制数据活动，将您的结果从 Azure 传输到您的 PC，并安排作业每周一运行一次。这在 ML 中是一个非常常见的模式，您可以使用 ADF 完全不写任何代码就能完成这项任务。

编辑 ML 管道以评分新数据

首先，您需要通过编辑第九章中创建的Iris-Scoring-Pipeline来创建一个新的 ML 管道，步骤如下：

在ml.azure.com访问你的 AML 工作室。
使用 GUI 创建一个新的数据集，就像你在第三章中做的那样，训练你的第一个 AutoML 模型。首先，在左侧面板下点击资产下的数据集。
点击Iris Local Scoring Data后。
在Input_Folder中选择Iris_Data.csv。这是你从你的 PC 上复制过来的数据。
完成创建数据集，确保在列标题下拉菜单下设置选项为使用第一个文件的标题，以便拉入列名。
创建你的数据集后，导航到你的 Jupyter 中的machine-learning-pipeline Python 笔记本。
点击左上角的文件，并从下拉框中选择创建副本。
将你的副本笔记本重命名为machine-learning-pipeline-local-scoring。
删除创建Iris数据的单元格，并将其注册为数据集。
在你的脚本的第一行中将 Python 脚本从Iris_Scoring.py重命名为Iris_Scoring_Local.py，如下所示：
```
%%writefile Scoring_Scripts/Iris_Scoring_Local.py 
```
在Iris_Scoring_Local.py中，检索你的Iris Local Scoring Data数据集，而不是如以下代码行所示的Iris Scoring数据集：
```
dataset =\
Dataset.get_by_name(ws,'Iris Local Scoring Data')
```

当配置你的 ML 管道步骤时，将Iris_Scoring.py替换为Iris_Scoring_Local.py，如下所示：

scoring_step =\
PythonScriptStep(name='iris-scoring-step',\
                script_name= 'Iris_Scoring_Local.py',\
                source_directory='Scoring_Scripts',\
                arguments=[],\
                inputs=[],\
               compute_target=compute_target,\
                runconfig=run_config,\
                allow_reuse=False)

在Iris_Scoring_Local.py中，在以下代码行中检索你的Iris Local Scoring Data数据集，而不是Iris Scoring数据集：
```
dataset =\
Dataset.get_by_name(ws,'Iris Local Scoring Data')
```

在以下代码行中，将你的已发布管道从Iris-Scoring-Pipeline重命名为Iris-Local-Scoring-Pipeline：

published_pipeline =\
pipeline_run.publish_pipeline( name='Iris-Local-Scoring-Pipeline',\
       description='Pipeline that Scores Iris Data', version= '1.0')

运行笔记本中的所有单元格以创建你的新 ML 管道Iris-Local-Scoring-Pipeline。这需要几分钟。你现在已经创建了一个从你的 PC 加载到 Azure 的评分数据集的 ML 管道。

创建 ADF 管道以运行你的 ML 管道

创建新的 ML 管道后，你现在可以创建一个新的 ADF 管道，使用以下步骤自动化端到端评分过程：

打开 ADF，点击左侧的笔形图标以打开 ADF 管道设计工具。
点击Copy Iris Data to Azure，并从下拉框中选择Clone。
将你的新管道重命名为End-to-End Iris Scoring。
通过点击绿色方块，按住鼠标按钮直到出现箭头，并将箭头连接到你的机器学习执行管道活动，如图 10.15所示：

图 10.15 – 在 ADF 管道中连接活动
通过选择活动并打开Iris-Scoring-Local-Pipeline，配置你的Score Iris Data，并在下拉框中选择唯一的机器学习管道 ID。
点击全部发布和发布以保存你的工作。
在活动下点击移动和转换，并将一个新的 Copy Data 活动拖到你的画布上。将其连接到 ADF 管道的末尾。
在选择新的活动后，点击将结果复制到 PC。
点击源并点击新建以开始创建新的输入数据文件。
选择Azure Blob Storage作为你的源目的地，并选择DelimitedText作为文件格式。点击继续。
填写 ADF 数据集创建表单。将此对象命名为ScoringResults。在 AML 数据存储的输出文件夹中选择Iris_Predictions.csv。完成后，表单应与图 10.16相匹配。点击确定：

图 10.16 – ADF 数据集创建表单
点击目标并点击新建以开始创建新的输出数据文件。
选择Azure Blob Storage作为你的源目的地，并选择DelimitedText作为文件格式。点击继续。
点击文件，选择文件系统，然后点击继续。
选择DelimitedText作为你的文件格式。点击继续。
填写 ADF 数据集创建表单。将此对象命名为ScoringLocalOutput。选择LocalPCLink作为你的链接服务。勾选第一行作为标题的复选框。点击确定。这将把你的文件保存在与你的输入数据相同的 PC 文件夹中。
点击目标并点击打开。这将打开一个新标签页，你可以在其中编辑目标数据。
将Iris_Scoring_Results.csv作为文件名进行编辑。
点击全部发布和发布以保存你的工作。

向 ADF 管道添加触发器

创建 ADF 管道的最后一步是添加一个触发器来自动化管道运行：

接下来，就像本章前面所做的那样添加一个触发器。点击添加触发器并选择新建/编辑。
点击选择触发器并选择新建。
将你的触发器命名为Monday Trigger，并设置为每周一上午 11:00 运行一次。确保你将时区设置为你的本地时区。点击确定两次。
点击全部发布和发布以保存你的工作。通过点击触发器（1）和立即触发来测试你的新 ADF 管道。你的管道应该像图 10.17中所示那样成功运行：

图 10.17 – 成功的端到端评分流程

现在，你已经创建了一个完全自动化的 AutoML 评分解决方案，该解决方案将在每周一上午 11:00 从你的本地 PC 中拉取数据并生成评分文件。在实际情况下，此解决方案将从定期更新的数据库中拉取数据。

这种技术适用于任何机器学习项目；你可以使用自定义训练的模型、视觉模型、AutoML 模型或任何其他类型的机器学习模型。这种模式适用于任何批处理评分场景，并且是所有行业中最常见的部署场景。练习它。

在您的工具包中有一个自动评分解决方案后，您的最终任务是构建一个自动训练解决方案。由于许多原因，ML 模型通常需要重新训练，并且当有新数据可用时应该重新训练。通过使用本节中使用的相同技术和模式，这将是一个简单的任务。

自动化端到端训练解决方案

就像任何其他 ML 模型一样，一旦 AutoML 模型部署并运行了几个月，它将受益于重新训练。这有很多原因，按重要性排序如下：

如果您输入数据和目标列之间的模式发生变化，ML 模型会崩溃。这种情况通常是由于消费者行为等外部因素的变化而发生的。当模式崩溃时，您需要重新训练模型以保持性能。
ML 模型接收到的相关数据越多，表现越好。因此，随着您的数据增长，您应该定期重新训练模型。
定期重新训练模型意味着如果模式随时间缓慢变化，它们不太可能崩溃。因此，在获取数据时重新训练是最佳实践。

在本节中，您将测试您的技能。您将获得一组类似于创建端到端评分解决方案时的指令。然而，这次将有显著较少的指导。如果您发现自己迷失方向，请仔细重读本章中的所有指令。

创建一个管道将数据复制到 Azure

首先，您需要创建一个 ADF 管道，将数据从您的 PC 复制到 Azure：

从 GitHub 存储库下载Iris_Training_Data_for_ADF.csv并将其放在您的 PC 上的Iris文件夹中：

github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Chapter10/Iris_Training_Data_for_ADF.csv
创建一个名为End-to-End Iris Training的新 ADF 管道。
在管道中创建一个Copy Iris Training Data from PC，将Iris_Training_Data_for_ADF.csv复制到您的 Azure 存储账户的Input_Folder。

参考您在自动化端到端评分解决方案部分创建的Copy Iris Data from PC活动。
运行此管道一次，将数据移动到 Azure。

编辑 ML 管道以使用新数据进行训练

接下来，复制并编辑您在第九章的实现批评分解决方案部分创建的automl-training-pipeline：

打开 AMLS 并创建一个名为Iris Local Training Data的新数据集。
打开您名为automl-training-pipeline的 Jupyter 笔记本。创建一个副本并将其重命名为automl-local-training-pipeline。
在 ML 管道中将Iris Training数据集替换为Iris Local Training Data数据集。使用名称Iris-AutoML-Training-Local-Pipeline运行和发布 ML 管道。

将机器学习执行管道活动添加到您的 ADF 管道中

最后，您将在 ADF 管道中添加一个活动来执行您刚刚创建的 ML 管道，如下所示：

在 ADF 中，添加一个名为Retrain Iris Model的活动。
向您的端到端 Iris 训练管道添加一个名为Tuesday Trigger的触发器。将此触发器安排在当地时间每周二早上 6:00 运行。
发布您的更改以保存您的作品。您的完成后的管道应该是一个两步过程，类似于图 10.18：

图 10.18 – 完成的重新训练管道

就这样！您已经创建了一个解决方案，该解决方案将自动每周使用新数据重新训练模型。在现实世界中，这将是从定期更新的数据库中提取数据，而不是从您的本地 PC 中提取。

请记住，您的训练 ML 管道会自动注册模型，而您的评分 ML 管道会自动重用您 ML 模型的最新版本。因此，从现在起无需手动更新这两个管道。

摘要

以端到端的方式自动化 ML 解决方案并非易事，如果您已经走到这一步，请感到自豪。大多数现代数据科学组织可以轻松地训练模型。但很少有人能够像本章中所做的那样实施可靠、自动化、端到端解决方案。

您现在应该对自己的能力充满信心，能够设计端到端的 AutoML 解决方案。您可以使用 AutoML 训练模型，创建 ML 管道来评分数据和重新训练模型。您可以使用 ADF 轻松地将数据导入 Azure 并将数据从 Azure 导出。此外，您可以将所有这些整合在一起，创建 ADF 管道，无缝地导入数据、评分数据、训练数据和将结果推送到您想要的地方。您现在可以创建端到端的 ML 解决方案。

第十一章，实现实时评分解决方案，将通过教授您如何在 AMLS 中使用 Azure Kubernetes Service 实时评分数据来巩固您的 ML 知识。将实时评分添加到您的批处理评分技能集中将使您成为一个更全面的实际 ML 专家，能够解决各种各样的问题。

第十一章：实现实时评分解决方案

虽然大多数机器学习（ML）项目涉及批量评分，但最复杂的 ML 项目使用实时解决方案。想想看，有哪些模型可以确定信用卡交易是否欺诈，有哪些模型可以决定向在线购物者展示哪些广告，以及有哪些模型可以决定汽车经销商的顾客是否有信用。所有这些情况都需要实时评分解决方案，并且确保您的模型既快速又准确至关重要。

幸运的是，无论您选择用 Python 编写代码还是使用Azure 机器学习（AML）工作室图形用户界面（GUI），在 AutoML 中创建快速、可靠的实时评分解决方案都很容易。

您将开始本章，通过 AML 工作室 GUI 创建实时评分端点。实时评分端点是通过它们传递数据并快速接收结果的 Web 服务。继续，您将通过 Python 代码使用 AzureML SDK 在 Jupyter 笔记本中创建实时评分端点。最后，您将学习如何提高实时评分端点的性能，以更好地服务您的最终用户。

到本章结束时，您将拥有更完整的数据科学技能集。能够训练模型、批量评分模型、按计划重新训练模型以及实时评分模型都是您将拥有的基本 ML 工程技能。这种技能集需求很高。此外，您将能够创建可以嵌入复杂场景中的实时评分端点。

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

通过 UI 创建实时端点
通过 SDK 创建实时端点
提高 AKS 集群的性能

技术要求

在本章中，您将创建在第四章，构建 AutoML 回归解决方案中创建的Diabetes-AllData-Regression-AutoML。

因此，您需要一个有效的互联网连接、一个Azure 机器学习服务（AMLS）工作区和一个计算实例。您还需要有创建 AKS 集群的权限。如果您使用的是个人账户，这不会成为问题。

以下是为本章准备的前提条件：

拥有互联网访问权限
拥有一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium
拥有微软 Azure 账户
已创建一个 AMLS 工作区
已在第二章，Azure 机器学习服务入门中创建了compute-cluster计算集群
了解如何从 Azure 计算实例导航到 Jupyter 环境，如第四章，构建 AutoML 回归解决方案中所示
在第四章，“构建 AutoML 回归解决方案”中已训练并注册了Diabetes-AllData-Regression-AutoML机器学习模型。

本章的代码在此处可用：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/tree/master/Chapter11。

通过 UI 创建实时端点

任何实时评分解决方案的核心都是一个实时评分端点，这是一个可以通过它传递数据并立即检索机器学习预测的 Web URL。端点托管在全天候运行、每周 7 天、等待接收请求的容器化服务上。

Requests可以将数据发送到端点进行评分，并且可以用任何计算机语言编写，包括 Python。一旦请求通过，你的端点将自动执行底层代码并返回结果。

你可以在任何地方使用这些端点；从 C#到 Python 到 Java 的任何编程语言都可以使用实时评分端点。因此，一旦你获得了托管端点的 URL，你就可以在任意其他代码中实现它。通常，实时评分端点被集成在流式作业、Web 应用程序和移动应用程序中。

当使用基于 AutoML 模型的实时评分端点时，有几个关键点需要注意，这些点使它们与你在第九章，“实现批量评分解决方案”中创建的批量评分管道有很大不同。具体如下：

首先，当将数据传递给使用 AutoML 训练模型进行评分的端点时，你必须以 JSON 格式传递输入数据，这是通过端点发送数据的最常见格式。Pandas 数据框或除 JSON 以外的任何格式都会失败。
其次，你不需要为评分 AutoML 训练模型编写 Python 脚本。Azure AutoML 会自动为你生成一个。因此，你传递给端点的数据必须具有评分所需的正确形状。除非你想更改 AutoML 生成的底层脚本，否则你无法在端点内部进行数据预处理。

AMLS 使用两个主要服务来托管端点，Azure 容器实例（ACI）和 AKS。两者都是容器化的，并使用 Docker。它们都可以通过 AML studio 中的 GUI 或通过 Jupyter 笔记本中的 Python SDK 来创建。ACI 轻量级、成本低，主要用于测试。AKS 功能强大、成本高，用于生产。

重要提示

ACI 和 AKS 之间的一个关键区别是身份验证。ACI 仅支持基于密钥的认证，而 AKS 支持基于密钥和基于令牌的认证。

在本节中，您将使用 AML 工作室 GUI 创建一个端点，使用您在 第四章 中构建的 Diabetes-AllData-Regression-AutoML ML 模型，该模型托管在 ACI 上。然后，您将通过 UI 创建一个AKS 集群；AKS 集群是一组虚拟机（VMs），它们全天候运行以托管您的端点。您将通过创建托管在您的 AKS 集群上的端点来结束本节。

总体而言，本节的目标是向您介绍端点，并展示您如何通过 AutoML 训练模型在几秒钟内轻松创建它们。

通过用户界面创建 ACI 托管的端点

首先，使用以下步骤创建一个使用 AI 的 Azure 容器实例：

通过导航到 ml.azure.com/ 打开您的 AML 工作室。
点击左侧面板下资产中的模型。
您将看到在 AMLS 工作空间中训练的所有 ML 模型的列表。点击 Diabetes-AllData-Regression-AutoML 的蓝色链接。
点击 AutoML_ 下的蓝色链接，后面跟着一个唯一字符的字符串（GUID）。
点击屏幕顶部的部署。
给您的端点命名为 diabetes-aci-gui。端点名称只能由小写字母、数字和破折号组成。
选择Azure 容器实例作为计算类型。
确认您的设置与以下截图匹配后，点击部署：

图 11.1 – ACI 设置
您的模型需要几分钟才能部署。等待足够的时间后，点击左侧面板下资产中的端点。

重要提示

第一次在 ACI 或 AKS 中创建端点时，AMLS 将创建一个容器注册表来托管它们。在任何情况下都不要删除此注册表，因为从那时起您将无法部署端点。
点击 diabetes-aci-gui 的蓝色链接。
点击屏幕顶部的消费按钮。
将 REST 端点 URL 复制到文本编辑器，如记事本。请注意，这里还有用于 C#、Python 和 R 中使用模型的代码。您现在已创建了一个在 ACI 上托管的运行得分端点。

在构建了 ACI 之后，您现在有一个可以用来评估新数据的运行端点。ACI 对于测试目的来说很棒，但为了创建一个生产就绪的解决方案，您需要 AKS。

通过用户界面创建 AKS 集群

在您可以在 AKS 上托管端点之前，您首先需要构建一个 AKS 集群。按照以下步骤使用 GUI 创建一个：

在管理下的左侧面板中点击计算。
点击屏幕顶部的推理集群。
点击创建。
选择中北部美国作为位置或您的 AMLS 工作空间所在的任何 Azure 位置。
使用右侧的搜索框搜索 Standard_DS3_v2。
选择 Standard_DS3_v2 作为您的虚拟机并点击下一步。
给你的 AKS 集群起一个名字。可以叫aks-amls-cluster。它的长度只能为 16 个字符。
选择开发/测试作为集群用途。
设置3。

重要提示

在创建 AKS 集群时，确保你的 VM 类型的核心数乘以节点数等于或大于 12。Standard_DS3_v2 VM 每个有 4 个核心，因此我们将节点数设置为4。这是一个最小要求。
一旦将你的设置与以下截图进行比较并确保它们匹配，点击创建：

图 11.2 – AKS 集群设置

现在你已成功创建了一个 AKS 集群。你可以使用这个集群来托管大量的 ML 模型。虽然 ACI 只适合运行大小不超过 1 GB 的模型，但你可以使用 AKS 集群来托管更大的模型。接下来，你将在该集群上创建一个端点。

通过 UI 创建 AKS 托管端点

为了创建一个托管在 AKS 上的实时评分端点，你需要遵循几乎与创建一个托管在 ACI 上的端点相同的步骤。首先，从以下步骤开始：

通过导航到ml.azure.com/打开你的 AML 工作室。
点击资产下左侧面板中的模型。
你将看到在这个 AML 工作空间中你训练的所有 ML 模型的列表。点击蓝色的链接打开Diabetes-AllData-Regression-AutoML。
点击AutoML_下的蓝色链接，后面跟着一个 GUID，一个独特的字符字符串。
点击屏幕顶部的部署。
给你的端点命名为diabetes-aks-gui。端点名称只能由小写字母、数字和破折号组成。
选择Azure Kubernetes Service作为计算类型。
打开启用身份验证开关。
选择基于密钥的身份验证作为类型。
在确认你的设置与以下截图匹配后，点击部署：

图 11.3 – AKS 设置
你的模型将需要几分钟的时间来部署，与你的 ACI 托管模型相同。一旦准备就绪，点击资产下左侧面板中的端点。
点击蓝色的链接打开diabetes-aks-gui。
点击屏幕顶部的消费。
将REST端点 URL 复制到文本编辑器，如记事本。同时，复制一个密钥。你可以使用主密钥或辅助密钥。任一密钥都可以用于身份验证。

通过本节，你现在已创建了两个实时评分端点，一个托管在 ACI 中，另一个托管在 AKS 中。你还有一个 AKS 集群来托管你的端点，并已将基于密钥的身份验证分配给你的 AKS 托管端点。通过 AML 工作室，通过点击消费，你也可以轻松找到用于在 C#、Python 和 R 中部署你的端点的代码。

在下一节，你将使用代码做同样的事情。此外，你还将测试你的端点以查看它们的工作情况。

通过 SDK 创建实时端点

通过 AML Studio 的一键部署非常简单，但大多数组织将要求你通过代码开发你的解决方案。幸运的是，通过 AzureML Python SDK 创建 AutoML 模型的实时评分端点几乎和通过 UI 创建它们一样简单。此外，你将更深入地了解你的端点是如何工作的，以及如何格式化你的 JSON 测试，以便将数据作为请求传递到端点。

在本节中，你将首先进入你的 Jupyter 环境，创建一个新的笔记本。首先，你将通过 ACI 部署你的 Diabetes-AllData-Regression-AutoML 模型，对其进行测试，一旦你确认测试成功，就通过代码创建一个新的 AKS 集群并将其部署在那里。你将通过测试你的 AKS 部署来结束本节，并确认一切按预期工作。

本节的目标是进一步加深你对实时评分端点的理解，教你如何通过代码创建一切，并使你能够构建和测试复杂的实时解决方案。

使用 Python 通过 ACI 创建和测试实时端点

每次你打算实时部署一个 ML 模型时，你应该首先将你的模型部署到 ACI 并对其进行测试。这样，你可以了解你的数据需要如何格式化，你的端点需要多长时间才能响应评分，以及你的模型是否正常工作。首先创建一个端点。

在 ACI 上创建一个实时评分端点

和前面的章节一样，你首先需要在你的计算实例上打开一个 Jupyter 笔记本。然后，按照以下步骤构建一个实时评分端点：

通过导航到 ml.azure.com/ 打开你的 AML Studio。
点击 Compute，启动一个计算实例，并打开一个 Jupyter 环境。
创建一个新的 Jupyter 笔记本，并将其命名为 real-time-endpoints。如果你需要复习，请查阅 第四章，构建 AutoML 回归解决方案。
使用以下代码导入你的标准 Azure 库：
```
from azureml.core import Workspace, Dataset, Datastore
from azureml.core import Experiment, Environment, Model
from azureml.core.compute import ComputeTarget, AksCompute
```
所有这些包你现在都应该很熟悉，除了 AksCompute。如果你需要复习，请查阅 第四章，构建 AutoML 回归解决方案，关于 Workspace、Dataset、Datastore、Experiment 和 ComputeTarget，以及 第九章，实现批量评分解决方案，关于 Environment 和 Model。AksCompute 允许你通过代码创建一个 AKS 集群。
使用以下代码导入你用于创建 ACI 端点的 Azure 库：
```
from azureml.core.model import InferenceConfig
from azureml.core.webservice import AciWebservice
from azureml.core.webservice import AksWebservice
from azureml.train.automl.run import AutoMLRun
```
InferenceConfig 允许你指定你将用于创建端点部署的 Python 脚本和环境。这个包与基于 AKS 和 ACI 的部署一起使用。

AciWebservice是您用于在 ACI 上创建端点的方式，而AksWebservice是您用于在 AKS 上创建端点的方式。AutoMLRun将允许您访问之前的 AutoML 训练运行。您将需要恢复在训练模型时创建的 Python 脚本。

重要提示

如果您在加载 Azure 库时遇到问题，请通过运行位于此处的Update AzureML SDK.ipynb笔记本来更新 AzureML SDK：github.com/PacktPublishing/Automated-Machine-Learning-with-Microsoft-Azure/blob/master/Update-AzureML-SDK.ipynb。
使用以下代码导入非 Azure 库：
```
import pandas as pd
import numpy as np
import random as r
import requests
import json
import os
```
您已经熟悉pandas、numpy、os和random。如果您需要复习，请参阅第四章，构建 AutoML 回归解决方案，或第九章，实现批量评分解决方案，以了解os和random。

在新包中，requests允许您向您的部署端点发送网络请求。此包将允许您测试您的部署并使用端点评分数据，而json允许您将数据转换为网络请求使用的 JSON 格式。
使用以下代码将您的 Jupyter 笔记本连接到您的 AMLS 工作区：
```
ws = Workspace.from_config()
```
如果提示您登录，请按照指示操作。
使用以下代码的第一行将您的数据存储设置为默认值。如果您想使用不同的数据存储，请使用第二行和第三行代码代替，替换workspaceblobstore：
```
datastore = Datastore.get_default(ws)
my_datastore_name = 'workspaceblobstore'
my_datastore = Datastore.get(ws, my_datastore_name)
```
使用以下代码将您的计算集群设置为在第二章，Azure 机器学习服务入门中创建的集群：
```
compute_name = 'compute-cluster'
compute_target = ComputeTarget(ws, compute_name)
```
使用以下代码将您的环境设置为AzureML-AutoML：
```
environment = Environment.get(ws, 'AzureML-AutoML')
```
AzureML-AutoML是随 AzureML SDK 一起提供的标准环境。您可以使用此环境进行任何实时 AutoML 部署。

提示

AzureML SDK 附带了许多不同的标准环境。您可以通过使用Environment.list函数访问它们的列表。
使用以下代码设置您的Diabetes-AllData-Regression-AutoML模型：
```
model = Model(ws, 'Diabetes-AllData-Regression-AutoML')
```
这是您将部署到端点以实时评分糖尿病数据的模型。
导航到您的 AML 工作室，在左侧面板上单击模型。您需要检索与您的模型关联的实验和运行 ID。
点击蓝色链接打开Diabetes-AllData-Regression-AutoML。
如果您在第四章，构建 AutoML 回归解决方案中逐字逐句遵循了指示，请复制Diabetes-Sample-Regression。

使用以下代码设置您的实验和运行 ID：

experiment = Experiment(ws, 'Diabetes-Sample-Regression') 
runID = 'AutoML_your_run_ID'

使用以下代码检索您的 AutoML 运行：
```
run = AutoMLRun(experiment, runID)
```
你检索旧运行的原因是为了从中提取用于部署模型的 Python 脚本。这是用于通过 GUI 部署你的模型的相同脚本。

重要提示

你可以使用此代码始终检索旧模型运行。如果你忘记注册模型，这很重要。你可以类似地检索旧的 ML 管道运行。
使用以下代码提取由 AutoML 最佳拟合的模型：
```
best_run, fitted_model = run.get_output()
```
此代码检索两个对象，最佳运行以及模型。你将只使用最佳运行，但 get_output() 需要你传递两个对象，否则函数将返回错误。
使用以下代码创建一个文件夹来保存所有你的实时脚本：
```
os.makedirs('Real_Time_Scripts', exist_ok=True)
```
使用以下代码检索你将用于实时评分数据的 Python 脚本：
```
script_path =\
'Real_Time_Scripts/Diabetes_Inference.py'
best_run.download_file('outputs/scoring_file_v_1_0_0.py', script_path)
```
当 AutoML 训练模型时，它会输出一个用于实时推理的评分文件。此文件始终称为 scoring_file_v_1_0_0.py，位于 outputs 文件夹中。此代码获取该文件并将其保存为 Diabetes_Inference.py。
设置一个变量来命名你的 ACI 部署：
```
aci_service_name = 'diabetes-scoring-aci'
```

使用以下代码配置端点以使用你的 Python 脚本和 Azure-AutoML 环境：

inference_config =\
InferenceConfig(entry_script=script_path,\
environment = environment)

使用以下代码配置你的 ACI 部署：

aci_config =\
AciWebservice.deploy_configuration(\
cpu_cores = 1, memory_gb = 1,\
tags = {'Project': 'Diabetes'},\
description = 'Diabetes Real-Time ACI Deployment')

注意你需要设置用于部署的核心数以及要保留的内存量。你还可以设置标签并添加描述。

使用以下代码创建你的 ACI 端点：

aci_service =\
Model.deploy(ws, aci_service_name,\
[model], inference_config, aci_config,overwrite=True)\
aci_service.wait_for_deployment(True)

此代码要求你传递你的 AMLS 工作空间、你的 ACI 部署名称、你的 ML 模型、你的端点（推理）配置、你的 ACI 配置，并将 overwrite 标志设置为 True 或 False。你的端点部署应花费 5 到 10 分钟。

测试你的实时评分端点

现在你已经在 ACI 上创建了一个实时评分端点，是时候测试它了。首先，你需要创建一些数据来测试它，然后你需要将其转换为 JSON 并按照以下步骤将其传递到端点：

要创建一些随机的 Diabetes 数据，首先，使用你在 第二章，Azure Machine Learning Service 入门 中创建的 Diabetes 样本数据集的最小值和最大值来为每个变量创建一个可能的值范围，使用以下代码：

AGE_range = np.arange(19,79,1)
SEX_range = np.arange(1,2,1)
BMI_range = np.arange(18.0,42.2,0.1)
BP_range = np.arange(62, 133, 1)
S1_range = np.arange(97, 301, 1)
S2_range = np.arange(41.6, 242.4, 0.1)
S3_range = np.arange(22, 99, 1)
S4_range = np.arange(2, 9.09, 0.01)
S5_range = np.arange(3.258, 6.107, 0.001)
S6_range = np.arange(58, 124, 1)

创建一个空列表以帮助生成样本数据。这与你在 第九章，实现批量评分解决方案 中创建样本 Iris 数据的方法类似。此外，创建一个空的 pandas dataframe 并使用以下代码将其列分配给它：
```
DiabetesList = []
columns =\
['AGE', 'SEX', 'BMI', 'BP', 'S1', 'S2', 'S3', 'S4', 'S5', 'S6']
DiabetesDF = pd.DataFrame(columns=columns)
```

使用以下代码使用 for 循环创建示例糖尿病数据：

for i in range(0,5):
    values = [r.choice(AGE_range),\
r.choice(SEX_range),r.choice(BMI_range),\
r.choice(BP_range), r.choice(S1_range),\
r.choice(S2_range), r.choice(S3_range),\
r.choice(S4_range), r.choice(S5_range),\
r.choice(S6_range)]
    DiabetesDict = pd.DataFrame(dict(zip(columns, values)), index=[0])
    DiabetesList.append(DiabetesDict)
DiabetesDF = DiabetesDF.append(DiabetesList,True)

此代码与用于创建 Iris 数据的代码相同。请参阅 第九章，实现批量评分解决方案，以获取详细说明。

使用以下代码将你的样本数据注册为名为 Diabetes Scoring：
```
Dataset.Tabular.register_pandas_dataframe(\
DiabetesDF, datastore, 'Diabetes Scoring')
```
这将把底层数据写入你的默认数据存储，并注册为名为 Diabetes Scoring 的数据集。
将 DiabetesDF 转换为以 {"data": 开头和 } 结尾的 JSON 对象。每个 AutoML 真实时部署都需要以这种格式的数据：
```
test = '{"data":' +\
DiabetesDF.to_json(orient='records') + '}'
```
重要提示

在创建 JSON 文件时，始终将 orient 设置为 records。任何其他 JSON 格式都可能导致错误。
查看你的数据以了解你的传入数据应该是什么样子：
```
Test
```
你的数据应该类似于 图 11.4，尽管值将根据你的数据而有所不同。关键点是 JSON 值需要以键值对的形式存在，以确保正确的预测：

图 11.4 – JSON 格式
导航到你的 AML 工作室首页并点击端点。
点击蓝色链接到 diabetes-scoring-aci 并点击消费。复制链接到你的端点的 URL 并将其粘贴到文本编辑器，如记事本。
返回到你的代码，将 URL 和头信息设置为变量：
```
aci_url = 'your-aci-endpoint-url'
headers = {'Content-Type': 'application/json'}
```
虽然你需要输入你的 URL，但头信息对于每次部署都是相同的。

使用以下代码测试你的 ACI 部署：

response =\
requests.post(aci_url, test, headers=headers)
print(resp.text)

你现在已经通过代码创建了一个在 ACI 上托管的真实时评分端点，并且已经成功测试了它。此外，你还了解你的数据需要以 JSON 格式进行塑形和格式化，以便进行评分。一旦你确认你的实时端点在 ACI 中工作正常，下一步就是创建一个 AKS 集群，并将生产版本部署在那里，就像你接下来要做的那样。

通过 Python 创建 AKS 集群

通过代码创建 AKS 集群与通过 GUI 创建一样简单直接。许多组织要求所有基础设施都通过代码创建，你可以使用以下步骤作为模板：

在你的 Jupyter 笔记本中继续操作，为你的虚拟机大小、所需节点数量、AKS 集群位置和 AKS 集群名称设置变量：
```
aks_cluster_name = 'aks-code-cluster'
vm_type = 'Standard_DS3_v2'
node_count = 3
AKS_location = 'northcentralus'
```
使用以下代码设置你的 AKS 集群配置：
```
prov_config =\
AksCompute.provisioning_configuration(vm_size =\
vm_type, agent_count = node_count, location =\
AKS_location)
```
在设置配置时，请记住，你的节点数乘以每个虚拟机上的核心数必须大于或等于 12。同时，在设置 Azure 位置时，考虑数据将从哪里传入。

使用以下代码创建你的 AKS 集群：

aks_target =\
ComputeTarget.create(workspace = ws, name =\
aks_cluster_name, provisioning_configuration =\
prov_config)
aks_target.wait_for_completion(show_output = True)

你必须传入你的 AMLS 工作区、AKS 集群名称和 AKS 集群配置。启动你的集群大约需要 5-10 分钟。

你已经通过代码创建了一个 AKS 集群。一旦它启动并运行，你就可以将评分端点部署到你的 AKS 集群，并使用你已创建的许多相同变量进行测试。因此，建议你在同一个 Jupyter 笔记本中创建 ACI 和 AKS 端点。这将节省你大量复制代码的工作。

通过 Python 使用 AKS 创建和测试实时端点

您在本节中的最后一个任务是部署您的实时评分端点到 AKS 集群，获取 URL 和访问密钥，并测试您的部署。只有几个步骤，因为您在部署到 ACI 时已经创建了大部分代码。

在本章结束时，请记住删除您的 AKS 端点和集群，因为它们可能相当昂贵，并可能产生账单。在同一个 Jupyter 笔记本中，继续以下步骤：

使用以下代码设置您的目标 AKS 集群：

aks_cluster = AksCompute(ws, 'aks-code-cluster')

为您的 AKS 部署设置一个变量名：

aks_service_name = 'diabetes-scoring-aks'

使用以下代码配置您的 AKS 部署：

aks_config =\
AksWebservice.deploy_configuration(cpu_cores = 1,\
                  memory_gb = 1, tags = {'Project':\
                  'Diabetes'}, description =\
                  'Diabetes Real-Time ACI Deployment')

注意，这些配置与您用于 ACI 部署的配置相同。

使用以下代码创建您的 AKS 端点：
```
aks_service =\
Model.deploy(ws, aks_service_name, [model],\
inference_config, aks_config, aks_cluster,\
overwrite=True)
aks_service.wait_for_deployment(show_output = True)
```
注意，此代码几乎与您用于创建 ACI 部署的代码相同；唯一的区别是您还必须传入 AKS 集群。这是因为 AKS 是托管在您管理的 VM 集群上，而 ACI 是一个无服务器容器服务。
导航到您的 AML 工作室首页并点击端点。
点击蓝色链接打开 diabetes-scoring-aks 并点击消费。复制链接到您的端点的 URL 并将其粘贴到文本编辑器（如记事本）中。同样，对于访问密钥，您可以使用主密钥或辅助密钥，任选其一。两者都适用。
回到您的代码，将您的 URL、密钥和头信息设置为变量：
```
aks_url = 'your-aks-endpoint-url'
key = 'your-aks-key'
headers = {'Content-Type': 'application/json'}
headers['Authorization'] = f'Bearer {key}'
```
在这里，您需要添加一个额外的头信息用于授权。Bearer 函数通过授予提供正确密钥的任何人访问权限来工作。

重要提示

在生产环境中，请确保将所有密钥存储在 Azure Key Vault 中，不要在公开代码中暴露您的密码和密钥。这是一个最佳实践，可以保护您。
使用以下代码测试您的 AKS 部署：
```
resp = requests.post(aks_url, test, headers=headers)
print(resp.text)
```
您应该看到与您的 ACI 测试相同的结果，因为它们使用相同的数据输入。确保输出匹配，您就可以称您的测试为成功。

您现在已经学到了成功在 Azure 中创建实时评分端点所需的所有知识。这些端点可以在任何其他代码片段中使用。确保推送到端点的任何数据都处于正确的 JSON 格式，您的项目将取得成功。

本章的最后部分处理优化 AKS 集群的性能。涉及一些微调，可以大大提高评分解决方案的响应时间。

提高 AKS 集群的性能

有时您会在 AKS 上部署一个端点，但它并不按您期望的方式运行。可能超时，可能太慢，可能是一个之前运行良好的端点突然面临无法处理的更多流量。这些情况会发生，您必须准备好应对它们。

幸运的是，AKS 部署有很多额外的配置，您可以利用这些配置来解决这些问题。本节将介绍一些更常见的情况，如下所示：

根据您的模型复杂度、您尝试评分的数据点数量以及虚拟机的大小，AKS 模型有时可能需要一段时间才能评分或甚至超时。在这种情况下，您有很多事情可以做。

首先，您可以尝试增加您虚拟机的尺寸，选择一个具有更多 RAM 的虚拟机。接下来，您可以在部署配置中添加一个额外的设置，scoring_timeout_ms。此设置默认为60000毫秒，即 1 分钟。您可以将其调整为最多300000毫秒，即 5 分钟。有时，调整memory_gb或增加cpu_cores的数量也可能有所帮助。
使用 AML studio 检查您模型的大小。您可以通过点击部署配置中的memory_gb设置来完成此操作。
在您的端点突然遇到无法处理的流量激增的情况下，尝试开启自动扩展并增加其扩展能力。在部署配置中将autoscale_enabled设置为True。

您还可以使用autoscale_min_replicas和autoscale_max_replicas手动调整自动扩展将创建的最小和最大副本数。这些默认值分别为1和10。在流量高峰的情况下，尝试将这两个值都提高以增加性能。

带着这些信息，您可以轻松创建满足您业务和性能要求的强大 AKS 部署。当流量繁忙时，提高自动扩展。当您的应用程序超时时，调整超时设置。当您的 AKS 端点运行缓慢时，尝试使用更大的虚拟机或调整内存设置。最重要的是，在 AKS 上部署之前，始终在 ACI 上测试您的部署，并确保输入数据以正确的 JSON 格式以键值对的形式传入。

摘要

您现在已创建并测试了使用 AutoML 训练模型的真实时评分解决方案。首先在 ACI 上部署，然后在 AKS 上部署，您理解了创建实时评分端点的完整端到端过程。

此外，您还了解为了使用这些端点生成预测，数据必须如何塑形和格式化，这些可以集成到任何使用各种计算机语言的代码中，以创建强大、创新解决方案。

在下一章，第十二章，利用 AutoML 实现商业价值，本书的最后一章，你将学习如何以一种能够赢得非技术业务伙伴信任的方式展示 AutoML 解决方案。毕竟，他们的信任和接受是解锁组织中机器学习和人工智能力量与价值的基础。

第十二章：利用 AutoML 实现商业价值

在这本书中，您已经获得了各种各样的技术技能。现在，您能够使用 AutoML 训练回归、分类和预测模型。您可以使用 Jupyter 笔记本在 Python 中编码 AutoML 解决方案，您知道如何导航 Azure Machine Learning Studio，甚至可以将机器学习管道集成到 Azure Data Factory (ADF) 中。然而，仅凭技术技能并不能保证您项目的成功。为了实现商业价值，您必须赢得最终用户的信任和接受。

在本章中，您将首先学习如何以使最终用户易于理解的方式展示端到端架构。然后，您将学习使用哪些可视化工具和指标来展示您模型的表现，之后您将学习如何可视化和解释 AutoML 内置的可解释性功能。

您还将探索在 Azure Machine Learning Service (AMLS) 之外运行 AutoML 的选项，并在本章结束时添加一个关于通过将您的信息与您提供的解决方案类型对齐来赢得最终用户信任的部分。

到本章结束时，您将准备好取得成功。您将获得一些必要的软技能，以便向最终用户传达您的解决方案，从而增加您的端到端解决方案被您的组织采用和使用的可能性。未能赢得最终用户信任是数据科学项目失败的主要原因之一，通过遵循本章中的指南，您将更有可能为您的解决方案创造兴奋点。

本章将涵盖以下主题：

架构 AutoML 解决方案
可视化 AutoML 模型结果
向您的业务解释 AutoML 结果
在其他 Microsoft 产品中使用 AutoML
实现商业价值

技术要求

在本章中，您将使用您在前面章节中创建的模型来检索图表、图表和指标。因此，您需要一个有效的互联网连接、Azure 账户和 AMLS 工作空间。您还需要完成 第四章**，构建 AutoML 回归解决方案 和 第五章**，构建 AutoML 分类解决方案 中的练习。

本章的先决条件如下：

上网权限。
一个网络浏览器，最好是 Google Chrome 或 Microsoft Edge Chromium。
一个 Microsoft Azure 账户。
一个 AMLS 工作空间。
您需要在 第四章**，构建 AutoML 回归解决方案 中训练并注册 Diabetes-AllData-Regression-AutoML 机器学习模型。
您需要在 第五章**，构建 AutoML 分类解决方案 中训练并注册了 Iris-Multi-Classification 机器学习模型。

本章没有新的代码。

架构 AutoML 解决方案

架构 AutoML解决方案是指绘制端到端图。这些图作为构建解决方案的蓝图，也可以用来向最终用户解释整个工作流程。虽然许多 IT 解决方案复杂且形式多样，但基于 AutoML 的解决方案遵循标准模式，需要你做出一些重要的决策。

在本节中，你将首先学习在架构决策之前需要做出哪些决策。然后，你将学习如何架构一个易于向最终用户解释的端到端批处理评分解决方案和端到端实时评分解决方案。尽管架构可能被简化，但越标准化，就越容易实施、解释和理解。

为 AutoML 解决方案做出关键架构决策

在绘制架构图时，你需要考虑几个关键因素，其中最重要的是你是否需要构建批处理或实时解决方案。批处理解决方案与实时解决方案的要求大不相同，通常遵循涉及 AMLS 和 ADF 的模板。另一方面，实时解决方案则更加定制化。

首先，我们将检查在构建批处理解决方案时需要提出的关键问题，因为它们更容易理解。你只需要考虑数据从哪里来，你的解决方案应该多久评分一次新数据，何时应该重新训练模型，以及最终用户将如何接收结果。就是这样。

同时，还有一个问题，那就是在你将各种机器学习（ML）管道安排在 AMLS 或 ADF 中进行调度时，应该如何协调。ADF 通常是最佳选择，因为它可以让你轻松地将数据移动到 Azure 中。以下表格提供了构建批处理解决方案的关键问题和答案的摘要：

图 12.1 – 批处理解决方案的关键考虑因素

另一方面，实时解决方案要复杂得多。你仍然需要询问输入数据从哪里来，你应该多久重新训练一次 AutoML 模型。此外，你还应该弄清楚你的端点将在哪里评分数据。这可能非常复杂，因为你在几乎任何地方都会使用你的端点。最常见的情况是，这将是一种某种类型的 Web 应用程序或无服务器代码片段。

最后，你需要弄清楚你的端点一次需要服务多少请求，最终用户需要多快的响应速度，以及你的Azure Kubernetes 服务（AKS）集群应该有多大，以便满足解决方案的需求。以下表格提供了构建实时解决方案的关键问题和答案的摘要：

图 12.2 – 实时解决方案的关键考虑因素

一旦您提出并回答了这些问题，您就可以开始构建架构图。首先，您将学习批处理解决方案的常见模式。

架构批处理解决方案

一旦您回答了输入数据来源和结果存放位置的问题，AutoML 批处理解决方案就相对容易构建。它们总是遵循大致相同的模式。首先，您将通过 ADF 从本地和云源摄取数据，并将数据存放在Azure Data Lake Storage Gen 2 (ADLS Gen 2)存储账户中。这使得您的数据可被 AMLS 访问。

一旦数据进入数据湖，您就可以在 AMLS 中使用 AutoML 来训练和注册一个机器学习模型。您的下一步是使用该模型创建评分管道和训练管道。然后，您通过 ADF 编排这两个机器学习管道，为评分管道和训练管道分别决定一个调度计划。

训练管道会自动在 AMLS 中注册您模型的最新版本，但您需要决定将评分管道的最终输出放置在哪里。默认情况下，评分管道被设计为将数据存放在 ADLS Gen 2 中。一旦数据在那里，您应该设置一个 ADF 复制活动，将数据从数据湖移动到其最终目的地。完整的端到端架构在以下图中展示：

图 12.3– 常见的批处理架构

为您制作的每个批处理 AutoML 解决方案创建类似的图，并在需要时重复使用它们。遵循模板架构将随着时间的推移使您和您的团队更加高效。

接下来，您将学习实时解决方案的常见架构。仔细注意相似之处和不同之处。虽然开始部分与批处理架构相同，但结尾部分却截然不同。

架构实时解决方案

实时解决方案架构需要更加仔细的考虑。如果有的话，您的最终用户将如何与您的端点交互？您是否正在设计一个用户可以随时评分数据的 Web 应用程序？您是否有一个一次向端点发送数千个信号的流系统？一旦这些问题得到解答，您就可以完全完善架构。

对于批处理解决方案，第一步涉及使用 ADF 将数据摄取到 ADLS Gen 2 中，并使用 AMLS 进行 AutoML 模型的训练和注册。这部分是相同的。一旦模型训练完成，您需要创建一个实时评分端点和机器学习训练管道。您将像往常一样在 ADF 中安排重新训练，以定期更新模型。

您还需要决定端点将驻留在何处。在这个架构中，它位于面向用户的 Web 应用程序上。用户可以在任何时间将数据传递到 Web 应用程序中，此时结果将在屏幕上显示，并立即发送到 ADLS Gen 2。以下图显示了完整的端到端架构：

图 12.4 – 常见的实时架构

向最终用户展示架构是获得解决方案接受的关键部分。最终用户需要以一般的方式了解一切是如何连接和工作的。在展示你的架构之后，你应该接着展示你的 AutoML 模型的结果。教用户如何使所有部件配合在一起只是一个介绍。以最终用户能够理解的方式展示你的模型结果，将大大有助于他们支持你的解决方案。

可视化 AutoML 建模结果

向你的业务展示你的 AutoML 模型的结果对于解决方案的采用至关重要。毕竟，如果你的最终用户不能确信它符合某些性能标准，他们不太可能采用你的解决方案。有几种方式可以展示 ML 模型的结果；展示结果最有效的方式是通过可视化。

幸运的是，AutoML 运行提供了回归、分类和预测结果的自动可视化。回归和预测具有相同的可视化，而分类则相当不同。在每种情况下，你只想与最终用户分享一个可视化；同一结果的多个视图可能会引起混淆。

在本节中，你将首先了解在分类之前向最终用户展示什么，然后转向回归和预测。

可视化分类结果

混淆矩阵，如第五章**，构建 AutoML 分类解决方案中所示，是展示 AutoML 分类训练运行结果的关键。最终，用户通常关心的是你的模型有多准确，以及是否存在假阳性或假阴性的倾向。为了获取这些信息，请按照以下步骤操作：

导航到ml.azure.com的 AML 工作室。
在左侧面板的资产下点击实验。
点击Iris-Multi-Classification的蓝色链接。这是你在第五章**，构建 AutoML 分类解决方案中用来训练分类模型的实验。
点击最新的运行蓝色的链接。这个链接位于AutoML_之后，跟着一个唯一的标识字符串。如果有多个运行，请使用最新的。
在屏幕顶部附近点击模型。
在算法名称下点击你性能最高的模型的名称的蓝色链接。它可能是StackEnsemble或VotingEnsemble。你会知道它是你的最高性能模型，因为它将是唯一一个带有查看解释链接的模型。
在屏幕顶部附近点击度量。
选择准确度和混淆矩阵的复选框。
在混淆矩阵中，点击下拉框并选择标准化。您应该会看到一个类似于以下图所示的图表：

图 12.5 – 为您的业务用户提供的分类结果

此图表包含您的最终用户所需的所有信息。首先，模型准确率为 98.7%。其次，它总是正确地识别Iris-setosa和Iris-virginica。最后，有 4%的可能性您的模型将错误地将Iris-versicolor识别为Iris-virginica。

在向您的业务用户解释结果时，保持这一级别的细节。解释说这是基于训练数据，并且您预计当应用于模型以前从未见过的数据时，结果可能会稍微差一些。

重要提示

样本量越大，您的样本数据越能代表现实世界，您的训练结果对新数据点的评分就越适用。这也是为什么始终重要的是收集尽可能多的好数据，并确保您的数据没有采样偏差。

通常，此图表将满足大多数最终用户对您的模型性能的疑问。由于 AutoML 生成的图表可能难以阅读，您可以采取的一个改进方法是使用其他工具（如 PowerPoint）重新创建此图表。回归和预测也有一个用于展示结果的非常强大的图表。

可视化预测和回归的结果

预测值与真实值图，首次在第四章**，构建 AutoML 回归解决方案中介绍，是展示这两种问题类型结果的关键。此图显示了您的模型在一系列分数上的性能。然而，它比混淆矩阵稍微难解释一些，需要您仔细向最终用户解释。要访问它，请按照以下步骤操作：

导航到ml.azure.com的 AML 工作室。
在左侧面板的资产下点击实验。
点击蓝色链接以打开Diabetes-Sample Regression。这是您在第四章**，构建 AutoML 回归解决方案中用于训练回归模型的实验。
点击蓝色链接以打开您的最新运行。此链接位于AutoML_之后，跟一个唯一的标识符字符串。如果有多个运行，请使用您的最新运行。
点击屏幕顶部的模型。
点击算法名称下的蓝色链接以打开您最高性能模型的名称。它可能是StackEnsemble或VotingEnsemble。您将知道它是您的最高性能模型，因为它将是唯一一个带有查看解释链接的模型。
点击屏幕顶部的指标。
勾选平均绝对百分比误差和预测真实值的复选框。您应该看到以下图中类似的图表：

图 12.6 – 为您的业务最终用户提供的回归/预测结果

平均绝对百分比误差（MAPE）通常是与商业误差一起使用的最佳回归指标。在这种情况下，它表明您的 AutoML 模型通常偏离了 39.4%，与您几乎完美的 Iris 模型相比并不特别令人印象深刻。商人往往认为 MAPE 是最容易理解的指标，因为它不需要统计学背景或对标准差或方差的深入了解。

预测值与真实值图显示了您的模型在预测一系列值时的表现如何。理想情况下，您希望您的蓝色线（平均预测值）与绿色线（理想）相匹配。至少，您希望大部分绿色线（理想）落在蓝色线（平均预测值）周围的阴影边界内。

您想要解释的是，对于 74.4 分到大约 250 分的分数，您的模型在预测真实分数方面做得相当不错。在这个范围之外，您的模型表现较差，倾向于高估 74.4 分以下的真实分数，低估 250 分以上的分数。使用以下直方图指出训练数据的分布情况。也许在光谱的更高端和低端收集更多的样本数据点将改善您的模型。

有时，一些有统计学背景的用户可能会成为您的最终用户之一。如果是这种情况，您还希望向他们展示通过勾选残差框可以获得的残差图。他们想知道您的模型是否显示出偏差的证据，通过展示以下图中所示的钟形残差直方图，您可以让他们放心：

图 12.7 – 回归和预测的残差直方图

预测在呈现结果方面与回归相同；它们使用相同的图表。通过向最终用户展示正确的可视化，您可以消除他们对性能的任何担忧。然而，他们通常会问一个后续问题。您的模型实际上是如何工作的？ 要回答这个问题，您需要使用 AutoML 的内置可解释性功能。

向您的业务解释 AutoML 结果

要实现商业价值，您的 AutoML 模型必须被业务实施并使用。实施的一个常见障碍是缺乏对机器学习工作原理的理解而产生的信任缺失。同时，解释个别机器学习算法的来龙去脉并不是赢得信任的好方法。将数学符号和复杂的统计数据抛向最终用户不会奏效，除非他们已经拥有深厚的数学背景。

相反，使用 AutoML 内置的可解释性。只要在训练模型时启用可解释性，您就可以确切地说出 AutoML 正在使用哪些特征来生成预测。通常，以下四个做法是好的：

在训练任何 AutoML 模型时，始终启用可解释性。
在向业务展示结果时，首先展示性能，然后展示可解释性。
按照重要程度从高到低排列特征。
从未来的训练运行中删除任何不重要的特征。

简单的模型更容易理解，并且更容易被最终用户接受。因此，您应该始终强调模型正在使用的特征。

为了访问可解释性，使用以下步骤：

导航到 AML 工作室在ml.azure.com。
在左侧面板的资产下点击实验。
点击蓝色链接打开Diabetes-Sample Regression。这是您在第四章**，构建 AutoML 回归解决方案中用于训练回归模型的实验。
点击蓝色链接打开您的最新运行。此链接位于AutoML_之后，跟随着一个唯一的标识字符串。如果有多个运行，请使用最新的。
在屏幕顶部附近点击模型。
点击查看解释。
在解释 ID下点击第一个 ID 号。这些是 AutoML 用于训练您的模型的原始特征的解释。
点击聚合特征重要性以查看在训练您的 AutoML 模型时哪些原始特征最重要。
使用滚动条查看用于训练您的模型的顶级 10 个特征，如图所示：

图 12.8 – 可解释性可视化

此可视化显示，用于训练Diabetes-AllData-Regression-AutoML模型的最重要两个特征是S5和BMI。血压(BP)、S3和SEX也很重要，但远不如S5和BMI重要。为了训练模型，S5和BMI的重要性是SEX的近 5 倍。剩余的五个特征，S2、S6、S1、AGE和S4，只是您机器学习模型的小贡献者；模型没有发现它们很重要。

重要提示

很可能您的商业伙伴会试图从这个图中推断因果关系。重要的是要记住，在没有受控的科学实验的情况下，任何机器学习模型中的可解释性只能显示相关性，而不能显示因果关系。

将此图表展示给您的最终用户以赢得他们的信任；它易于理解，并清楚地显示了 AutoML 正在使用哪些功能进行预测。您不仅可以看到正在使用哪些功能，还可以展示您数据集中每一列的相对重要性。使用此图表讲述一个引人入胜且有意义的故事；您甚至可以从向您的商业受众展示此图表并询问他们的解读开始。让他们讲述故事并自行制定解决方案。

在解释了架构和性能之后，最好展示可解释性幻灯片。架构以端到端格式解释了解决方案是如何工作的，而没有深入到技术细节。性能使您的用户对模型在任何给定时间可以预期的准确性有信心。从逻辑上讲，您的用户将询问您的 AutoML 模型是如何进行预测的。这就是您展示可解释性图表而不是深入到统计和算法错误的地方。

在涵盖了架构、性能可视化以及可解释性之后，您现在拥有了赢得最终用户信任和接受所需的所有工具。下一节将扩展您可以使用 AutoML 来扩展您可开发解决方案的范围的各种地方。即使在 AMLS 之外使用 AutoML，也要记住始终使用可解释性。

在其他 Microsoft 产品中使用 AutoML

在这本书中，您已经学习了如何在 Azure 上使用 AutoML，但您也可以在更广泛的 Microsoft 产品套件中使用 AutoML。虽然您可以根据本章“架构 AutoML 解决方案”部分中的架构模式轻松创建和产品化几乎任何 AutoML 解决方案，但在某些场景中，您可能希望在其他 Microsoft 平台上使用 AutoML。您可以在以下位置找到 AutoML：

PowerBI
Azure Synapse Analytics
ML.NET
HDInsight
SQL Server
Azure Databricks

尽管 AutoML 可用于这些服务，但您应该注意许多差异。一些服务是无代码的，而另一些则是仅限代码。一些服务阻止您训练预测算法，而另一些则基于完全不同的 ML 框架。在本节中，您将按服务逐一了解其一般功能。

在 PowerBI 中使用 AutoML

PowerBI是微软的商业分析解决方案，允许用户可视化数据以快速获得洞察。它是市场上最受欢迎且功能强大的仪表板工具之一，软件的Power BI Premium和Power BI Embedded许可证都允许您直接使用 AutoML。这是一个无代码版本的 AutoML，其工作方式类似于您在 AML studio 中找到的 AutoML GUI，如图 12.7所示：

图 12.9 – PowerBI 中的 AutoML

在这种情况下，AutoML 与 PowerBI 数据流集成，这是一个自助式数据准备工具。与 Azure 上的 AutoML 一样，你可以用它来训练模型、保存（注册）模型，并使用模型进行预测，这些预测可以保存为数据中的新列。与 Azure 上的 AutoML 不同，它只支持回归和分类问题，不支持预测。这两个服务共有的另一个特性是模型可解释性。

如果你是一名经常构建数据可视化仪表板的数据分析师，PowerBI 上的 AutoML 是一个很好的工具，可以添加到你的工具箱中。你可以轻松地将预测直接添加到数据中，并花费很少的努力来可视化它们。PowerBI 上的 AutoML 对于一次性的 ML 作业也非常出色。Azure Synapse Analytics 是数据分析师使用 AutoML 的另一个常见服务。

在 Azure Synapse Analytics 中使用 AutoML

Azure Synapse Analytics（ASA）是 Azure 的顶级数据分析服务。它提供了一个用于大数据的 SQL 数据仓库、基于 Spark 的分析以及类似 ADF 风格的 ETL 管道，所有这些都在一个地方。如果你有一个 AMLS 工作空间，并且使用类似于 ADF 的链接服务将其链接到 ASA，你还可以在 Synapse 中直接使用 Azure AutoML。

为了使用 AutoML，你需要有一个 Spark 集群，并从你的数据中创建 Spark 表。Spark 是一个开源的分析引擎，用于通过在虚拟机集群中分配工作负载来快速处理大数据。使用 ASA，你可以使用 PySpark（Python 的一个版本）、C#、Spark SQL 或 Scala 编写 Spark 解决方案。Spark 表只是在这个框架内创建的数据表。

一旦你有了 Spark 表，你所需要做的就是右键点击它，点击机器学习，然后点击使用新模型丰富。随后你会看到一个非常熟悉的界面：你最初在第三章**，训练你的第一个 AutoML 模型中使用的 AutoML GUI。由于 ASA 直接使用你的 AMLS 工作空间通过 AutoML 训练模型，因此其功能和用户体验是相同的。你还可以在 ASA 中使用 PySpark（Python 的一个版本）、C#、Spark SQL 或 Scala 编写 AutoML 解决方案。

最好将 Synapse 的 AutoML 功能视为一种快捷方式，而不是与 AMLS 不同的体验。当你已经在 ASA 中工作，并希望快速使用 ASA 数据仓库中的数据训练一个 ML 模型时，请使用它。

使用 ML.NET 与 AutoML

.NET 框架是一个软件开发框架，允许你使用 C#、F# 和 Visual Basic 构建应用程序。ML.NET 允许你将 ML 功能添加到 .NET 框架中，而 AutoML 是其众多功能之一。你可以在应用程序中编码 ML.NET 解决方案，或者使用 ML.NET 模型构建器通过引导式用户界面创建 AutoML 解决方案。

ML.NET 模型构建器的一个有趣方面是，你可以为各种预定义场景使用 AutoML，包括回归、分类、图像分类、文本分类和目标检测。因此，你不仅限于仅使用表格数据，还可以使用带有图像的自动机器学习。

如果你正在构建 .NET 应用程序并希望轻松地将机器学习添加到其中，请尝试在 ML.NET 中使用 AutoML。这是最合适的用例，并且假设你在 .NET 框架中开发有丰富的经验。如果你不是 .NET 开发者，你最好在 AMLS 工作区中开发你的 AutoML 解决方案。

在 SQL Server、HDInsight 和 Azure Databricks 上使用 AutoML

AutoML 还可在多种其他服务上使用，包括 SQL Server、HDInsight 和 Azure Databricks。SQL Server 是微软知名的 关系数据库管理系统（RDBMS），而 HDInsight 是 Azure 的 Hadoop 版本，用于处理大数据。Azure Databricks 是 Azure 上用于大数据处理和分析的顶级云基础 Spark 工具。这三个服务都可以通过 Python 使用 Azure AutoML。

当使用这些工具时，你首先需要创建一个 AMLS 工作区，安装 AzureML-SDK，并将你的 AMLS 工作区连接到其他服务。然后，你需要编写一个解决方案。在 HDInsight 和 Databricks 中，你将使用 Spark，而在 SQL Server 中，你需要使用 sp_execute_external_script 存储过程来运行 Python 代码。存储过程是可以保存并重复使用的 SQL 代码片段。

这三个服务与 ASA、PowerBI 和 ML.NET 之间的重要区别是，AutoML 没有引导用户界面选项。你必须使用代码创建解决方案。如果你已经在 SQL Server、HDInsight 或 Azure Databricks 中构建应用程序或数据管道，并希望将 AutoML 作为该解决方案的一部分，那么在那些服务中进行模型训练是自由的。

Azure Databricks 的另一个特定用例是当你想要使用非常大的数据（100 GB 数据框）训练 AutoML 模型时；这时使用 Spark 分布式框架运行 AutoML 是合适的。

现在你已经熟悉了 AutoML 可用的许多不同工具，你将在构建 AutoML 解决方案时拥有更多的灵活性。然而，仅仅因为你已经构建了一个解决方案，并不意味着人们会使用它。为了总结本章和本书，最后一节将关注获得最终用户接受的战略和技术，这是实现商业价值的关键。

实现商业价值

实现商业价值最终取决于你的商业伙伴是否选择根据你的 ML 模型的预测采取行动。没有行动，数据科学家的工作就只是科学实验。你的商业伙伴必须被激励并愿意将你的预测纳入他们的决策过程中。赢得他们的信任至关重要。

为了赢得公司决策领导层的信任，你首先必须确定你使用 AutoML 构建的是哪种解决方案。一些解决方案很容易且迅速地被采用，而其他解决方案可能会遇到强烈的阻力。

有两个关键因素决定了你的 AutoML 解决方案被接受的程度：你的工具是否在替换现有的解决方案，以及你的工具是否直接参与自动化决策过程或是在协助人类决策者。图 12.8显示了基于这些因素获得接受度有多困难：

图 12.10–基于关键因素获得商业用户支持难度

你的解决方案越自动化，就越容易获得接受。毕竟，在引擎盖下运行的流程不受人类监督。没有人类手动决定每笔信用卡交易是否欺诈；这项任务只能通过自动化流程来完成。

由于一开始就没有人在循环中，所以在尝试使用 ML 模型改进自动化流程时，你不太可能遇到阻力。相反，当你尝试用 AI 生成的预测来增强人类决策者的决策时，你很可能会遇到怀疑和阻力。

同样，全新的解决方案比替换旧解决方案的工具更容易被接受。虽然用 AI 解决方案替换现有的自动化系统也是如此，但当你在尝试替换高管和经理用来做决策的现有系统时，这一点更为明显。许多人对于他们不完全理解的变化反应迟缓。

在本节中，我们将介绍基于关键因素赢得信任并让商业用户采用基于 AutoML 的解决方案的策略。

让商业用户采用新的自动化解决方案

这很简单。想象一下，如果你的公司正在构建一个新的销售门户，他们希望创建一个系统，当在线购物者在你的网站上浏览商品时，自动为它们生成产品推荐。你提议构建一个推荐系统，使用 AutoML 训练 ML 模型，并使用托管在 AKS 上的实时评分端点对模型进行评分。

很可能，你对提案的回应将会得到压倒性的积极反馈。你的高管团队会对你采用尖端 AI 技术的举措印象深刻。负责该项目的商业管理团队仅仅拥有一个高性能的解决方案就会感到高兴。你的 IT 部门会对学习新技术感兴趣，并且非常乐意帮助你实施一个新的大型项目。

如果有任何阻力，那将来自那些想要更好地理解你的 AI 解决方案工作原理的人。因此，建议你提供模型解释，以及 ML 和 AutoML 是如何工作的概述。如果人们能够向其他人解释它是如何工作的，他们更有可能支持你的项目，所以努力发展这种理解。

让企业替换旧的自动化流程

用基于 ML 的新解决方案替换旧的自动化解决方案比创建一个全新的流程要困难一些。这通常是因为商业用户已经理解了旧流程的工作方式。如果你试图替换一个基于一系列 if-then 语句的规则系统，这会更加困难，因为旧流程对人类来说更容易理解。

在这种情况下，你的最佳策略是将你的基于 AutoML 的新解决方案的结果与旧解决方案的结果并排比较几周或几个月。不要立即关闭旧流程；你应该同时运行这两个流程，直到你的最终用户确信并对你的 ML 模型的输出有信心。只有在这种情况下，你才应该关闭并永久关闭旧解决方案。

你可能认为解释 ML 和 AutoML 的工作原理将是你的最佳策略，但习惯于一个系统的最终用户可能会错误地假设 AI 的工作方式与旧解决方案相似。消除这种观念可能很困难，而且极端的方法差异可能会让一些用户失去信任。因此，在提供深入详细的解释之前，最好首先引导你的最终用户关注结果。一旦他们信任你的结果，他们自然会开放地接受这个过程。

让企业采用新的决策辅助工具

在向一群决策者提供 AI 生成的建议或预测时，一个关键的认识是，对于当前的问题，他们已经做出了多年的决策。他们可能还没有工具，但他们确实有自己的直觉和多年的经验。因此，他们通常对新工具或技术持怀疑态度，这些工具或技术声称可以帮助他们在工作中。记住，没有人是通过做出糟糕的决策而上升到公司高层的。

在这种情况下，最好的办法是试图通过向他们保证这只是一个提供预测或建议的工具来平息他们的恐惧。这是建议。它可能是 AI 生成的，但最终，建议就是建议，最终的决定仍然掌握在他们手中。

一个有用的类比是，在棋类世界中，AI 可能打败大师，但由 AI 辅助的大师可以打败 AI。人类最终仍然掌握着控制权。

你还应该强调 ML 生成的预测的统计性质。它们并不完美，也不是不可犯错的。如果你预测下个月市场份额将下降到 11.3%，置信区间为±0.2%，但实际上下降到 11.1%，那么你的模型是正确的，并且处于预期范围内。

如果你的模型告诉你某个篮球运动员有 70%的机会在你的球队中表现良好，但那个球员失败了，那么你的模型仍然是正确的，但 30%的机会发生了。

重要提示

在制作决策辅助的 AI，如大多数预测模型时，确保你的模型尽可能准确，并且不会在准确性上出现大幅波动非常重要。没有任何事情比一个波动很大的模型更快地失去信任。

通过强调你只提供建议，并且这些建议具有统计性质，你的模型有更高的可能性在长时间内被商业界使用。如果它只是建议，他们不会感到受到威胁，而且当统计上不太可能的事情发生时，他们也不会停止使用你的模型，因为他们理解这偶尔会发生。

让商业界替换旧决策辅助工具

在获得商业受众接受方面，最困难的项目之一是当你用 ML 驱动的工具替换一个旧的工具时。在这种情况下，你正在替换的工具可能已经存在了很多年。

许多经验丰富的用户可能会反对新的流程或解决方案，无论它如何改善当前状态。这是由于熟悉度偏差，即人类对熟悉事物比对不熟悉事物的偏好。

克服熟悉度偏差，并让商业用户采用你的解决方案是一项相当大的挑战，需要系统性地进行。首先，就像替换一个较旧的自动化流程一样，你不应该关闭旧解决方案；你需要让它继续运行，这样你才能对比结果。如果你不这样做，经验丰富的用户可能会负面且不公平地将你的工具与旧解决方案进行比较；他们需要看到这比旧解决方案有所改进。

比较结果并排是必要的，但不足以获得最终用户的接受。此外，你需要让用户理解你生成的 AutoML 解决方案。

对 AI 解决方案的一种常见批评是难以理解它们是如何工作的。相比之下，你正在替换的系统已经拥有了数年的时间来向其用户传授其细节。因此，你应该将可解释性幻灯片放在你的解决方案的最前沿；你还应该解释架构，并确切地说明 AutoML 是如何工作的，你计划何时重新训练模型，以及你计划如何持续评估和监控解决方案。

逐个建立信任的方法对你的解决方案的成功也大有裨益。在你与所有最终用户分别进行一系列一对一会议之后，再向整个团队展示你的解决方案。

如果最终用户太多，识别并会见群体中最有影响力的人。通过解决他们的担忧，对他们进行解决方案培训，并鼓励他们与其他最终用户交谈，你将能够建立一个支持你的解决方案的群体，增加其长期成功的可能性。

按难度顺序，从最容易到最困难，以下是获得最终用户信任并保证长期采用解决方案类型的列表：为新自动化流程设计的 AutoML 解决方案，替代自动化流程的 AutoML 解决方案，帮助人类做出决策的 AutoML 解决方案，替代现有决策辅助工具的 AutoML 解决方案。以下表格提供了总结：

图 12.11 – 基于 AutoML 解决方案类型如何建立信任

如您所见，仅仅因为你构建了一个高性能的 AutoML 解决方案，并不意味着它会被业务采用。你还需要同样努力地赢得最终用户的信任。通过确定你正在构建的 AutoML 解决方案类型并遵循适当的指南，你将能够一次赢得一个最终用户的信任。一旦足够多的人支持你的解决方案，它将朝着成为长期成功和采用的信任工具集迈进。

摘要

获得最终用户的接受可能很困难，但采用正确的方法可以使这变得容易得多。通过向最终用户展示架构图，仔细地使用正确的指标向他们解释模型的性能，并花时间解释模型用于做出预测的特征，这些都是向最终用户销售你的解决方案的关键。此外，你可以根据你正在构建的解决方案类型定制你的信息，以赢得最终用户的信任。

你现在已到达本书的结尾，我希望你能回顾这段旅程。你已经掌握了许多技术技能，包括训练 AutoML 模型、批量部署 AutoML 模型进行评分以及实时评分，以及设计、创建和实施全栈式 AutoML 解决方案的能力。你还有一套方法向你的商业伙伴推销这些解决方案，赢得他们的信任，并最终实现价值。通过在 Azure 上使用 AutoML 构建强大的解决方案，你将能够产生持久的影响并推进你的职业生涯。

posted @ 2025-09-04 14:14 绝不原创的飞龙阅读(12) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

微软-Azure-自动机器学习-全-

微软 Azure 自动机器学习（全）

前言

本书面向对象

本书涵盖内容

为了充分利用本书

下载示例代码文件

下载彩色图像

使用的约定

联系我们

评论

第一部分：AutoML 解释 - 为什么、是什么、怎么做

第一章：介绍 AutoML

解释数据科学的投资回报率问题

定义机器学习、数据科学和人工智能

机器学习与传统软件的比较

机器学习成功的五个步骤

理解业务问题

收集和清洗数据

为机器学习转换数据

训练机器学习模型

向最终用户交付结果

整合所有内容

慢慢分析为什么 AI 项目失败

利用 AutoML 解决投资回报率问题

Azure 上 AutoML 的优势

摘要

第二章：Azure 机器学习服务入门

技术要求

创建你的第一个 AMLS 工作区

创建 Azure 账户

创建 AMLS 工作空间

使用代码创建 AMLS 工作区

导航 AML 工作室

构建计算以运行您的 AutoML 作业

创建计算实例

创建计算集群

使用代码创建计算集群

使用 Azure CLI 创建计算集群和计算实例

在 AMLS 中处理数据

使用 GUI 创建数据集

使用代码创建数据集

理解 Azure 上的 AutoML 是如何工作的

使用数据守卫确保数据质量

通过智能特征工程改进数据

使用迭代数据转换对数据进行归一化以进行机器学习

使用迭代机器学习模型构建快速训练模型

使用机器学习模型集成获得最佳结果

摘要

第三章：训练你的第一个 AutoML 模型

技术要求

将数据加载到 AMLS 以进行 AutoML

创建一个 AutoML 解决方案

解释你的 AutoML 结果

理解数据安全栏

理解模型指标

解释你的 AutoML 模型

获得更好的 AutoML 性能

摘要

第二部分：回归、分类和预测的 AutoML – 一份逐步指南

第四章：构建 AutoML 回归解决方案

技术要求

准备 AutoML 回归数据

设置您的 Jupyter 环境

为 AutoML 准备你的数据

训练 AutoML 回归模型

注册您的训练回归模型

微调你的 AutoML 回归模型

提高 AutoML 回归模型

理解 AutoML 回归算法

摘要

第五章：构建 AutoML 分类解决方案

技术要求

准备 AutoML 分类数据

导航到你的 Jupyter 环境

加载数据并进行转换

训练一个 AutoML 分类模型

注册你的训练分类模型