成为谷歌云机器学习工程师-全-

成为谷歌云机器学习工程师（全）

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

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

自从 1946 年第一台可编程数字计算机 ENIAC 来到我们的世界以来，计算机已经被广泛使用，并成为我们生活的一个组成部分。想象一个没有计算机的世界是不可能的。

进入 21 世纪，所谓的ABC 三角形在计算机世界中脱颖而出，其三个顶点代表当今最先进的计算机技术——A 代表人工智能，B 代表大数据，C 代表云计算，正如您可以从以下图中看到。这些技术正在重塑我们的世界，每天都在改变我们的生活。

从历史的角度来看这些先进的计算机技术非常有趣，可以了解它们是什么以及它们是如何相互发展的：

• 人工智能（AI）是一种使机器（计算机）能够模拟人类行为的技术。机器学习（ML）是人工智能的一个子集，它使机器能够自动从过去的数据中学习并基于数据预测。人工智能大约在 1956 年进入世界，就在 ENIAC 发明之后不久，但近年来，由于大数据的积累和云计算的发展，人工智能得到了快速发展。

• 大数据指的是过去几年中持续指数级增长的数据。到 2018 年，全球产生的数据总量约为 33 泽字节（1 ZB = 8,000,000,000,000,000,000,000 位）。这个数字在 2020 年增长到 59 ZB，预计到 2025 年将达到令人难以置信的 175 ZB。处理这些大数据集需要巨大的计算能力。在普通计算机上处理这些巨大的数据集是不可能的，更不用说公司部署传统数据中心来放置这些计算机所需的时间。大数据处理需要新的提供计算能力的方法。

• 云计算在 2006 年进入我们的世界，大约在人工智能概念提出后的半个世纪。云计算提供了具有弹性、自助配置和按需服务的计算能力。在传统的计算模型中，基础设施被视为硬件。硬件解决方案是物理的——它们需要空间、人员、规划、物理安全和资本支出——因此它们有一个漫长的硬件采购周期，涉及获取、配置和维护。云计算模型将基础设施视为软件——选择最适合您业务需求的云计算服务，按需配置和终止这些资源，根据需求弹性地自动扩展和缩减资源，以不可变代码的形式部署基础设施/资源，并按使用付费。在云计算模型中，计算资源被视为临时和可丢弃的：它们可以更快、更轻松、更经济地使用。云计算模型使人工智能计算成为可能。

人工智能、大数据和云计算相互协作并蓬勃发展——更多的数据导致更多的 AI/ML 应用，更多的应用需要更多的云计算能力，而更多的应用将产生更多的数据。

以其创新驱动的思维方式和行业趋势驱动的产品而闻名，谷歌是ABC 三角形技术领域的领导者。作为机器学习的先驱，谷歌在 2017 年开发了 AlphaGo，这是第一个击败专业人类围棋世界冠军的计算机程序。AlphaGo 在数千场人类业余和专业比赛中进行训练，以学习如何下围棋。AlphaZero 跳过这一步骤，并学会与自己下棋——它迅速超越了人类水平，并以 100 比 0 的成绩击败了 AlphaGo。除了传奇的 AlphaGo 和 AlphaZero 之外，谷歌还在视觉、语音和语言处理等多个领域开发了众多机器学习模型和应用。在云计算领域，谷歌是世界上最大的云计算服务提供商之一。谷歌云平台（GCP）提供了地球上最好的云服务，特别是在大数据和机器学习领域。许多公司都热衷于使用谷歌云，并利用 GCP 机器学习服务来满足他们的业务用例。这正是我们编写本书的目的。我们旨在了解并掌握最好的最佳——谷歌云中的机器学习。

本书面向的对象

这本书适合任何不仅想要更好地理解云中机器学习（ML）的概念，而且已经有一定掌握并希望深入研究成为专业谷歌认证云机器学习工程师的人。

本书涵盖的内容

第一章，理解谷歌云服务，提供了对 GCP 服务的概述，其中详细介绍了附录 1中的实践示例。

第二章, 学习 Python 编程，深入探讨了 Python 基础知识及编程技能。Python 数据科学库被探讨，实践示例详见附录 2。

第三章, 准备机器学习开发，涵盖了机器学习过程的前期准备，包括机器学习问题定义和数据准备。

第四章, 开发和部署机器学习模型，深入探讨了机器学习过程，包括平台准备、数据集拆分、模型训练、验证、测试和部署，实践示例详见附录 3。

第五章, 理解神经网络和深度学习，通过神经网络建模介绍了现代人工智能的深度学习方法。

第六章, 学习 BQML、TensorFlow 和 Keras，发现 Google 的 BigQuery 机器学习用于结构化数据，以及 Google 的机器学习框架 TensorFlow 和 Keras。

第七章, 探索 Google Cloud Vertex AI，检查了 Google 的端到端机器学习套件 Vertex AI 及其机器学习服务，实践示例详见附录 4。

第八章, 发现 Google Cloud ML API，探讨了如何利用 Google 的预训练模型 API 进行机器学习开发，实践示例详见附录 5。

第九章, 使用 Google Cloud ML 最佳实践，总结了在 Google Cloud 中进行机器学习开发的最佳实践。

第十章, 获得 GCP 机器学习认证，通过整合前几章学到的知识和技能，研究 GCP 机器学习认证考试问题。

附录 1, 使用基本 GCP 服务进行实践，提供了配置基本 GCP 服务的示例。

附录 2, 使用 Python 数据库进行实践，提供了 Python 数据库实践示例，包括 NumPy、Pandas、Matplotlib 和 Seaborn。

附录 3, 使用 ScikitLearn 进行实践，提供了 scikit-learn 库实践示例。

附录 4, 使用 Google Vertex AI 进行实践，提供了练习 Google Cloud Vertex AI 服务的示例。

附录 5, 使用 Google Cloud ML API 进行实践，提供了 Google Cloud ML API 实践示例。

为了充分利用这本书

在 Google Cloud 中学习机器学习是一个很好的实践，分为两个方面：学习章节以掌握基本概念，并通过实际操作章节中的所有实验示例来学习，特别是附录中的实验。

虽然开始时需要一些基本的计算机技术知识，但成为云开发者或云工程师并不是必需的。您可以从头到尾阅读这本书，或者您可以跳到似乎与您最相关的章节。

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

下载示例代码文件

您可以从 GitHub 下载本书的示例代码文件 github.com/PacktPublishing/Journey-to-a-Google-Cloud-Professional-Machine-Learning-Engineer。如果代码有更新，它将在 GitHub 仓库中更新。

我们还有其他来自我们丰富的图书和视频目录的代码包，可在 github.com/PacktPublishing/ 获取。查看它们吧！

下载彩色图像

我们还提供了一份包含本书中使用的截图和图表的彩色 PDF 文件。您可以从这里下载：packt.link/ugTOg。

使用的约定

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

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

代码块设置如下：

html, body, #map {
 height: 100%; 
 margin: 0;
 padding: 0
}

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

[default]
exten => s,1,Dial(Zap/1|30)
exten => s,2,Voicemail(u100)
exten => s,102,Voicemail(b100)
exten => i,1,Voicemail(s0)

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

$ mkdir css
$ cd css

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

小贴士或重要提示

看起来像这样。

联系我们

我们欢迎读者的反馈。

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

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

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

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

分享您的想法

一旦您阅读了《成为谷歌云机器学习工程师之旅》，我们很乐意听听您的想法！请点击此处直接访问此书的亚马逊评论页面并分享您的反馈。

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

第一部分：从 GCP 和 Python 开始

本部分提供了谷歌云平台（GCP）和 Python 编程语言的一般背景。我们介绍了云计算和 GCP 的概念，并简要概述了基本 GCP 服务，包括计算、存储、网络、数据库、大数据和机器学习。我们概述了 Python 语言的基础知识、编程结构和控制流程。然后，我们讨论了 Python 数据科学库，包括 NumPy、Pandas、Matplotlib 和 Seaborn，以更好地理解它们的函数和使用案例。

本部分包括以下章节：

• 第一章, 理解谷歌云服务

• 第二章, 学习 Python 编程

第一章：理解谷歌云服务

在本书的第一部分，我们将通过关注谷歌云和 Python（分别是我们学习旅程的必要平台和工具）来建立基础。

在本章中，我们将深入探讨 谷歌云平台（GCP）并讨论与 谷歌云机器学习密切相关的谷歌云服务。掌握这些服务将为我们提供坚实的基础。

本章将涵盖以下主题：

• 理解 GCP 全球基础设施

• 开始使用 GCP

• GCP 组织结构

• GCP 身份和访问管理

• GCP 计算谱系

• GCP 存储和数据库服务

• GCP 大数据和数据分析服务

• GCP 人工智能服务

让我们开始吧。

理解 GCP 全球基础设施

谷歌 是世界上最大的云服务提供商之一。凭借谷歌全球数据中心中的物理计算基础设施，如计算机、硬盘驱动器、路由器和交换机，这些数据中心通过谷歌的全球骨干网络连接，谷歌在 GCP 中提供了一系列全面的云服务，包括计算、网络、数据库、安全和大数据、机器学习（ML）等高级服务。

在谷歌的全球云基础设施中，有许多数据中心组。每个数据中心组被称为 GCP 区域。这些区域遍布全球，包括亚洲、澳大利亚、欧洲、北美和南美。这些区域通过谷歌的全球骨干网络连接，以优化性能和增强弹性。每个 GCP 区域是一组相互隔离的 区域。每个区域有一个或多个数据中心，并由一个结合字母标识符和区域名称的名称来标识。例如，区域 US-Central1-a 位于 US-Central1 区域，该区域位于美国爱荷华州的 Council Bluffs。在 GCP 全球基础设施中，还有许多 边缘位置 或 接入点（POPs），谷歌的全球网络通过这些位置连接到互联网。有关 GCP 区域、区域和边缘位置的更多详细信息，请参阅 cloud.google.com/about/locations。

GCP 在全球范围内提供按需云资源。这些资源可以一起使用来构建帮助满足业务目标和满足技术要求解决方案。例如，如果一家公司需要在东京需要 1,000 TB 的存储空间，其 IT 专业人员可以登录他们的 GCP 账户控制台，在任何时候在亚洲东北 1地区配置存储空间。同样，可以在悉尼配置 3,000 TB 的数据库，在法兰克福配置 4,000 节点的集群，只需点击几下即可。最后，如果一家公司想要为全球用户提供最低延迟的全球网站，例如zeebestbuy.com，他们可以在全球区域的伦敦、弗吉尼亚和新加坡建立三个 Web 服务器，并利用谷歌的全球 DNS 服务将这些 Web 流量分配到这三个 Web 服务器。根据用户的 Web 浏览器位置，DNS 将路由流量到最近的 Web 服务器。

开始使用 GCP

现在我们已经了解了谷歌的全球云基础设施和云计算的按需资源配置概念，我们迫不及待地想要深入谷歌云并在云中配置资源！

在本节中，我们将通过以下步骤构建云资源：

• 创建免费层级的 GCP 账户

• 在谷歌云中配置虚拟计算机实例

• 在谷歌云中配置我们的第一个存储

让我们详细地逐一介绍这些步骤。

创建免费层级的 GCP 账户

谷歌为我们提供了一个免费层账户类型，以便我们开始在 GCP 上操作。更多详细信息可以在cloud.google.com/free/docs/gcp-free-tier找到。

一旦您注册了 GCP 免费层账户，就是时候规划我们在谷歌云中的第一个资源了——一台计算机和一个云存储文件夹。我们将按需配置它们。多么令人兴奋啊！

在谷歌云中配置我们的第一台计算机

我们将从最简单的想法开始：在云中配置一台计算机。暂时想想家里的电脑。它有一个中央处理器（CPU），随机存取存储器（RAM），硬盘驱动器（HDDs），以及一个网络接口卡（NIC）来连接到相关的互联网服务提供商（ISP）设备（如电缆调制解调器和路由器）。它还有一个操作系统（Windows 或 Linux），并且可能有一个数据库，如 MySQL 用于家庭数据管理，或者 Microsoft Office 用于家庭办公使用。

要在谷歌云中配置计算机，我们需要对其硬件进行相同的规划，例如 CPU 的数量、RAM 的大小以及 HDD 的大小，以及对其软件的规划，例如操作系统（Linux 或 Windows）和数据库（MySQL）。我们可能还需要规划计算机的网络，例如外部 IP 地址，以及 IP 地址是否需要静态或动态。例如，如果我们计划配置一个 Web 服务器，那么我们的计算机将需要一个静态的外部 IP 地址。从安全的角度来看，我们还需要设置网络防火墙，以便只有家庭或工作地点的特定计算机可以访问我们云中的计算机。

GCP 为消费者提供了一种在云中配置计算机的云服务：Google Compute Engine（GCE）。通过 GCE 服务，我们可以在谷歌云中构建灵活的、自我管理的虚拟机（VM）。GCE 根据消费者的需求提供不同的硬件和软件选项，因此您可以使用定制的 VM 类型并为 VM 实例选择合适的操作系统。

按照以下说明进行操作 cloud.google.com/compute/docs/instances/create-start-instance，您可以在 GCP 中创建一个虚拟机。让我们在这里暂停一下，转到 GCP 控制台来配置我们的第一个计算机。

我们如何访问计算机？如果 VM 运行的是 Windows 操作系统，您可以使用远程桌面来访问它。对于 Linux VM，您可以使用安全外壳（SSH）进行登录。更多详细信息请参阅 cloud.google.com/compute。

在谷歌云中配置我们的第一个存储

当我们打开计算机机箱并查看我们家庭计算机的内部时，我们可以看到其硬件组件——即其 CPU、RAM、HDD 和 NIC。PC 内的硬盘在大小和性能上都是有限的。EMC，由理查德·伊根和罗杰·马诺在 1979 年创立的公司，在 1990 年将 PC 硬盘扩展到 PC 机箱外的独立计算机网络存储平台，称为Symmetrix。Symmetrix 拥有自己的 CPU/RAM，并提供巨大的存储容量。它通过光纤电缆连接到计算机，并作为计算机的存储阵列。另一方面，SanDisk，由 Eli Harari、Sanjay Mehrotra 和 Jack Yuan 于 1988 年创立，在 2000 年生产了第一个基于 Flash 的固态硬盘（SSD），名为Cruzer。Cruzer 通过 USB 连接到计算机提供便携式存储。通过跳出思维定式，扩展到 Symmetrix 或 Cruzer，EMC 和 SanDisk 将硬盘概念扩展到了盒子之外。这些都是创业想法的绝佳例子！

然后是云计算的伟大想法——存储的概念进一步扩展到云块存储、云网络附加存储（NAS）和云对象存储。让我们更详细地看看这些：

• 云块存储是一种基于软件的存储形式，可以附加到云中的虚拟机，就像硬盘在我们的家用电脑上一样。在 Google Cloud 中，云块存储被称为 持久磁盘（PD）。无需购买物理硬盘并将其安装在电脑上使用，PD 可以立即创建并附加到云中的虚拟机，只需几个点击即可。

• 云网络附加存储（Cloud NAS）是一种基于软件的存储形式，可以通过虚拟云网络在许多云虚拟机之间共享。在 GCP 中，云 NAS 被称为 Filestore。无需购买物理文件服务器，将其安装在网络上并与多个家庭电脑共享，只需几个点击即可创建 Filestore 实例，并由许多云虚拟机共享。

• 云对象存储是一种基于软件的存储形式，可以用于在云中存储对象（文件、图像等）。在 GCP 中，云对象存储被称为 Google Cloud Storage（GCS）。与 PD 不同，PD 是一种云块存储类型，由虚拟机使用（可以在多个虚拟机之间以只读模式共享），以及 Filestore，它是一种由多个虚拟机共享的云 NAS 类型，GCS 是一种用于存储不可变对象的云对象类型。对象存储在 GCS 存储桶中。在 GCP 中，可以通过 GCP 控制台进行存储桶创建和删除、对象上传、下载和删除，只需几个点击即可！

GCS 根据对象访问模式提供不同的存储类别。更多详细信息可以在 cloud.google.com/storage 找到。

按照位于 cloud.google.com/storage/docs/creating-buckets 的说明，您可以创建存储文件夹/存储桶并将对象上传到其中。让我们在这里暂停一下，转到 GCP 控制台来配置我们的第一个存储桶并将一些对象上传到其中。

使用 GCP Cloud Shell 管理资源

到目前为止，我们已经讨论了从 GCP 控制台在云中配置虚拟机和存储桶/对象。还有一个工具可以帮助我们创建、管理和删除资源：GCP Cloud Shell。Cloud Shell 是一个可以通过控制台浏览器轻松访问的命令行界面。在您点击 GCP 控制台上的 Cloud Shell 按钮后，您将获得一个 Cloud Shell – 在您的网络浏览器中，一个带有所有云资源管理命令的虚拟机命令行用户界面。

以下工具由 Google 提供，供客户使用命令行创建和管理云资源：

• gcloud 工具是 GCP 产品和服务（如 GCE）的主要命令行界面。

• gsutil 工具用于 GCS 服务。

• bq 工具用于 BigQuery 服务。

• kubectl 工具用于 Kubernetes 服务。

请参阅cloud.google.com/shell/docs/using-cloudshell-command获取有关 GCP Cloud Shell 和命令的更多信息，以及如何使用 Cloud Shell 命令创建虚拟机（VM）和存储桶。

GCP 网络 – 虚拟私有云

再次思考家庭电脑——它们都通过网络连接，有线或无线，以便连接到互联网。没有网络，电脑几乎毫无用处。在 GCP 中，云网络单元被称为虚拟私有云（VPC）。VPC 是一种基于软件的逻辑网络资源。在 GCP 项目中，可以配置有限数量的 VPC。在云中启动虚拟机（VM）后，您可以在 VPC 内连接它们，或者将它们隔离在不同的 VPC 中。由于 GCP VPC 是全球性的，并且可以跨越世界上的多个区域，因此您可以在世界任何地方配置 VPC，以及其中的资源。在 VPC 内，公共子网包含具有外部 IP 地址的虚拟机，这些 IP 地址可以从互联网访问，并且可以访问互联网；私有子网包含没有外部 IP 地址的虚拟机。VPC 可以在 GCP 项目内或项目外相互对等。

可以使用 GCP 控制台或 GCP Cloud Shell 配置 VPC。有关详细信息，请参阅cloud.google.com/vpc/。让我们在这里暂停一下，转到 GCP 控制台以配置我们的 VPC 和子网，然后在这些子网中启动一些虚拟机。

GCP 组织结构

在我们进一步讨论 GCP 云服务之前，我们需要花一些时间来讨论 GCP 组织结构，它与亚马逊网络服务（AWS）云和微软 Azure 云的结构相当不同。

GCP 资源层次结构

如以下图所示，在 GCP 云域内，最上面是 GCP 组织，然后是文件夹，接着是项目。作为一项常见做法，我们可以将公司的组织结构映射到 GCP 结构中：公司映射到 GCP 组织，其部门（销售、工程等）映射到文件夹，而来自部门的职能项目映射到文件夹下的项目。云资源，如虚拟机（VM）、数据库（DB）等，位于项目下。

在 GCP 组织层次结构中，每个项目都是一个独立的隔间，每个资源恰好属于一个项目。项目可以有多个所有者和用户。它们分别管理和计费，尽管多个项目可能与同一个计费账户相关联：

图 1.1 – GCP 组织结构示例

在前面的图中，有两个组织：一个用于生产，一个用于测试（沙盒）。在每一个组织下，都有多层文件夹（注意文件夹层数和每层的文件夹数量可能有限），在每个文件夹下，都有多个项目，每个项目包含多个资源。

GCP 项目

GCP 项目是 GCP 资源的逻辑分隔。项目用于根据 Google Cloud 的 身份和访问管理（IAM）权限完全隔离资源：

• 计费隔离：使用不同的项目来分隔支出单元

• 配额和限制：在项目级别设置，并按工作负载分隔

• 管理复杂性：在项目级别设置以实现访问分离

• 影响范围：配置问题在项目内受限

• 职责分离：业务单元和数据敏感性是分开的

总结来说，GCP 组织结构为管理 Google Cloud 资源提供了一个层次结构，其中项目是逻辑隔离和分离。在下一节中，我们将通过查看 IAM 来讨论 GCP 组织内的资源权限。

GCP 身份和访问管理

一旦我们审查了 GCP 组织结构以及 VM、存储和网络等 GCP 资源，我们必须查看这些资源在 GCP 组织内的访问管理：IAM。GCP IAM 使用 AAA 模型管理云身份：身份验证、授权和审计（或会计）。

身份验证

在 AAA 模型中的第一个 A 是 身份验证，它涉及验证试图访问云的云身份。与传统方式仅要求提供用户名和密码不同，多因素身份验证（MFA）被使用，这是一种要求用户使用多种独立方法验证其身份的认证方法。出于安全原因，所有用户身份验证，包括 GCP 控制台访问和任何其他 单点登录（SSO）实现，都必须在强制执行 MFA 的同时进行。用户名和密码在当今时代简单地无法保护用户访问。

授权

授权在 AAA 模型中由第二个 A 表示。它是在用户已认证到云账户后，授予或拒绝用户访问云资源的过程。用户可以访问的信息量和服务的数量取决于用户的授权级别。一旦用户的身份得到验证并且用户已认证到 GCP，用户必须通过授权规则才能访问云资源和数据。授权决定了用户可以和不能访问的资源。

授权定义了谁可以在哪个资源上做什么。以下图表显示了 GCP 中的授权概念。如您所见，授权过程中有三个参与者：图中的第一层是身份 – 这指定了谁可以是用户帐户、用户组或应用程序（服务帐户）。第三层指定了哪些云资源，例如 GCS 存储桶、GCE 虚拟机、VPC、服务帐户或其他 GCP 资源。服务帐户也可以是一个身份以及一个资源：

图 1.2 – GCP IAM 身份验证

中间层是IAM 角色，也称为什么，它指的是身份对资源具有的特定权限或操作。例如，当一组用户被授予计算查看者的权限时，该组将只能对 GCE 资源进行只读访问，无法写入/更改它们。GCP 支持三种类型的 IAM 角色：原始（基本）、预定义和自定义。让我们看看：

• 原始（基本）角色包括所有者、编辑者和查看者角色，这些角色在 IAM 引入之前就存在于 GCP 中。这些角色在所有 Google Cloud 服务中都有数千个权限，并赋予显著的权限。因此，在生产环境中，除非没有其他选择，否则建议不要授予基本角色。相反，授予满足您需求的限制性预定义角色或自定义角色。

• 预定义角色根据基于角色的权限需求提供对特定服务的细粒度访问。预定义角色由 Google 创建和维护。Google 会根据需要自动更新其权限，例如当 Google Cloud 添加新功能或服务时。

• 自定义角色根据用户指定的权限列表提供细粒度访问。这些角色应谨慎使用，因为用户负责维护相关的权限。

在 GCP 中，身份验证是通过 IAM 策略实现的，这些策略将身份绑定到 IAM 角色。以下是一个示例 IAM 策略：

{
  "bindings": [
    {
      "members": [
        "user:jack@example.com"
      ],
      "role": "roles/resourcemanager.organizationAdmin"
    },
    {
      "members": [
        "user:jack@example.com",
        "user:joe@example.com"
      ],
      "role": "roles/resourcemanager.projectCreator"
    }
  ],
  "etag": "BwUjMhCsNvY=",
  "version": 1
}

在前面的示例中，Jack（jack@example.com）被授予了预定义的组织管理员角色（roles/resourcemanager.organizationAdmin），因此他有权访问组织、文件夹和有限的项目操作。Jack 和 Joe（joe@example.com）都可以创建项目，因为他们已被授予项目创建者角色（roles/resourcemanager.projectCreator）。这两个角色绑定共同为 Jack 和 Joe 提供了细粒度的 GCP 资源访问权限，尽管 Jack 拥有更多的权限。

审计或会计

在 AAA 模型的第三个 A 指的是 审计 或 会计，这是跟踪用户访问 GCP 资源活动的过程，包括在网络中花费的时间、他们访问的服务以及登录会话期间传输的数据量。审计数据用于趋势分析、访问记录、合规审计、违规检测、取证和调查、账户计费、成本分配和容量规划。使用 Google Cloud Audit Logs 服务，您可以跟踪用户/组和他们的活动，并确保活动记录是真实的。审计日志对于云安全非常有帮助。例如，回溯到网络安全事件的记录对于取证分析和案件调查可能非常有价值。

服务帐户

在 GCP 中，服务帐户是一种专用帐户，可以由 GCP 服务和其他在 GCE 实例或其他地方运行的应用程序用来与 GCP 应用程序编程接口 (APIs) 交互。它们就像 程序化访问用户，通过它们您可以赋予访问 GCP 服务的权限。服务帐户存在于 GCP 项目中，但可以在组织和文件夹级别以及不同的项目中分配权限。通过利用服务帐户凭证，应用程序可以授权自己访问一组 API 并在授予服务帐户的权限范围内执行操作。例如，运行在 GCE 实例上的应用程序可以使用该实例的服务帐户与其他 Google 服务（如 Cloud SQL 数据库实例）及其底层 API 交互。

当我们创建第一个虚拟机时，同时为该虚拟机创建了一个默认的服务帐户。您可以通过定义其 访问范围 来定义此虚拟机服务帐户的权限。一旦定义，在此虚拟机上运行的所有应用程序都将拥有相同的权限来访问其他 GCP 资源，例如 GCS 存储桶。当虚拟机的数量显著增加时，这将生成大量的服务帐户。这就是我们经常创建一个服务帐户并将其分配给需要具有相同 GCP 权限的虚拟机或其他资源的原因。

GCP 计算服务

之前，我们探讨了 GCE 服务并在云中创建了我们的虚拟机实例。现在，让我们看看整个 GCP 计算谱系，它包括 Google Compute Engine (GCE), Google Kubernetes Engine (GKE), Cloud Run, Google App Engine (GAE), 和 Cloud Functions，如下面的图所示：

图 1.3 – GCP 计算服务

GCP 计算谱系提供了广泛的企业用例。根据业务模式，我们可以选择 GCE、GKE、GAE、Cloud Run 或 Cloud Functions 来满足需求。我们将在接下来的几节中简要讨论每个服务。

GCE 虚拟机

我们讨论了围绕 GCE 和使用云控制台和 Cloud Shell 部署的虚拟机的相关概念。在本节中，我们将讨论 GCP GCE 虚拟机镜像和定价模式。

计算引擎镜像为在 计算引擎（即虚拟机）中运行的应用程序提供基本操作系统环境，它们对于确保您的应用程序快速、可靠地部署和扩展至关重要。您还可以使用金/受信任镜像来存档应用程序版本以用于灾难恢复或回滚场景。GCE 镜像在安全性方面也至关重要，因为它们可以用于部署公司中的所有虚拟机。

GCE 为虚拟机提供不同的定价模式：按需付费、抢占式、承诺使用量和独占主机。

按需付费适用于需要即时配置虚拟机的业务场景。如果工作量可预测，我们希望使用承诺使用量以获得折扣价格。如果工作量可以重启，我们希望进一步利用 抢占式 模型并竞标虚拟机价格。如果存在与主机相关的许可证，则 独占主机 类型符合我们的需求。有关 GCE 虚拟机定价的更多详细信息，请参阅 cloud.google.com/compute/vm-instance-pricing。

负载均衡器和托管实例组

单台计算机可能因硬件或软件故障而宕机，并且在计算能力需求随时间变化时也无法提供任何扩展。为确保高可用性和可伸缩性，GCP 提供了 负载均衡器（LBs）和 托管实例组（MIGs）。LBs 和 MIGs 允许您创建同构的实例组，以便负载均衡器可以将流量定向到多个虚拟机实例。MIG 还提供自动扩展和自动修复等功能。自动扩展允许您通过配置自动扩展策略中的适当最小和最大实例来处理流量峰值，并根据特定信号调整虚拟机实例的数量，而自动修复则执行健康检查，并在必要时自动重新创建不健康的实例。

让我们通过一个例子来解释这个概念：

图 1.4 – GCP 负载均衡器和托管实例组

如前图所示，www.zeebestbuy.com 是一家全球电子商务公司。每年，当 黑色星期五 来临，他们的网站负载非常重，以至于单个计算机无法容纳流量——需要更多的网络服务器（运行在虚拟机实例上）来分配流量负载。黑色星期五之后，流量会恢复正常，不需要那么多实例。在 GCP 平台上，我们使用负载均衡器（LB）和迁移组（MIG）来解决这个问题。如前图所示，我们在全球范围内建立了三个网络服务器（美国弗吉尼亚北部、新加坡和英国伦敦），GCP DNS 可以根据用户的浏览器位置和到三个站点的延迟将用户流量分配到这些位置。在每个站点，我们设置一个 LB 和一个 MIG：根据正常和高峰流量，可以适当地设置所需的容量、最小容量和最大容量。当 黑色星期五 来临，LB 和 MIG 一起弹性地启动新的虚拟机实例（网络服务器）来处理增加的流量。黑色星期五销售结束后，他们将停止/删除虚拟机实例以反映减少的流量。

MIG 使用启动模板，类似于启动配置，并指定实例配置信息，包括虚拟机镜像的 ID、实例类型、扩展阈值以及其他用于启动虚拟机实例的参数。LB 使用健康检查来监控实例。如果实例在配置的阈值时间内没有响应，将根据启动模板启动新的实例。

容器和 Google Kubernetes Engine

就像从物理机到虚拟机的转变一样，从虚拟机到容器的转变是革命性的。我们不再启动一个虚拟机来运行应用程序，而是将应用程序打包成一个标准单元，这个单元包含运行应用程序或服务所需的一切，以便在不同的虚拟机上以相同的方式运行。我们将包构建成一个 Docker 镜像；容器是 Docker 镜像的运行实例。当虚拟化程序将硬件虚拟化为虚拟机时，Docker 镜像将操作系统虚拟化为应用程序容器。

由于松散耦合和模块化可移植性，越来越多的应用程序正在被容器化。很快，就出现了一个问题：如何管理所有这些容器/Docker 镜像？这就是 Google Kubernetes Engine（GKE）发挥作用的地方，这是 Google 开发的一个容器管理系统。一个 GKE 集群通常至少包含一个控制平面和多个被称为节点的工人机器，它们协同工作来管理/编排容器。Kubernetes Pod 是一组一起部署并协同工作以完成任务的容器。例如，一个应用服务器 Pod 包含三个独立的容器：应用服务器本身、一个监控容器和一个日志容器。协同工作，它们构成了业务用例中的应用程序或服务。

按照以下说明cloud.google.com/kubernetes-engine/docs/how-to/creating-a-zonal-cluster，您可以创建一个 GKE 区域集群。让我们在这里暂停一下，并使用 GCP Cloud Shell 创建一个 GKE 集群。

GCP Cloud Run

GCP Cloud Run 是一个托管计算平台，允许您在完全托管的环境或 GKE 集群中运行无状态的容器，这些容器可以通过 HTTP 请求被调用。Cloud Run 是无服务器的，这意味着所有基础设施管理任务都是 Google 的责任，让用户专注于应用程序开发。使用 Cloud Run，您可以使用任何语言以及您想要的任何框架和工具来构建应用程序，然后几秒钟内即可部署，无需管理服务器基础设施。

GCP Cloud Functions

与分别部署 VM 或容器以运行应用程序的 GCE 和 GKE 服务不同，Cloud Functions 是一种无服务器计算服务，允许您提交代码（用 JavaScript、Python、Go 等语言编写）。Google Cloud 将在后台运行代码并将结果发送给您。您不知道也不关心代码在哪里运行——您只需为代码在 GCP 上运行的时间付费。

利用 Cloud Functions，一段代码可以在几毫秒内根据某些事件被触发。例如，当一个对象被上传到 GCS 存储桶后，可以生成并发送一条消息到 GCP Pub/Sub，这将导致 Cloud Functions 处理该对象。Cloud Functions 也可以根据您定义的 HTTP 端点或 Firebase 移动应用程序中的事件被触发。

使用 Cloud Functions，Google 负责运行代码的后端基础设施，让您只需专注于代码开发。

GCP 存储和数据库服务范围

之前，我们探讨了 GCS 服务，并在云中创建了我们的存储桶，以及为我们的云 VM 实例创建的持久磁盘和 Filestore 实例。现在，让我们看看整个 GCP 存储和数据库服务范围，包括 Cloud Storage、Cloud SQL、Cloud Spanner、Cloud Firestore、Bigtable 和 BigQuery，如下所示：

图 1.5 – GCP 存储和数据库服务

在这里，Cloud Storage 存储对象，Cloud SQL 和 Cloud Spanner 是关系型数据库，Cloud Firestore 和 Bigtable 是 NoSQL 数据库。BigQuery 也是一个数据仓库以及大数据分析/可视化工具。我们将在 GCP 大数据和数据分析服务 部分讨论 BigQuery。

GCP 存储

我们已经讨论了 GCP 存储，包括 Google Cloud Storage（GCS）、持久磁盘和 Filestore。GCS 是 GCP ML 作业存储其训练数据、模型、检查点和日志的常见选择。在接下来的几节中，我们将讨论更多 GCP 存储数据库和服务。

Google Cloud SQL

Cloud SQL 是一个完全托管的 GCP 关系型数据库服务，支持 MySQL、PostgreSQL 和 SQL Server。使用 Cloud SQL，您可以在本地运行熟悉的相同关系型数据库，无需自我管理的麻烦，如备份和恢复、高可用性等。作为一个托管服务，Google 负责管理数据库备份、导出和导入、确保高可用性和故障转移、执行补丁维护和更新，以及执行监控和日志记录。

Google Cloud Spanner

Google Cloud Spanner 是一个具有无限全球规模、强一致性以及高达 99.999% 可用性的 GCP 完全托管的关系型数据库。与关系型数据库类似，Cloud Spanner 有模式、SQL 和强一致性。同样，与非关系型数据库类似，Cloud Spanner 提供高可用性、水平可伸缩性和可配置的复制。Cloud Spanner 已被用于关键业务用例，如在线交易系统的交易和财务管理。

Cloud Firestore

Cloud Firestore 是一个快速、完全托管、无服务器、云原生的 NoSQL 文档数据库。Cloud Firestore 支持 ACID 事务，并允许您在无需性能下降的情况下对 NoSQL 数据进行复杂查询。它在全球范围内存储、同步和查询移动应用和 Web 应用的数据。Firestore 与 Firebase 和其他 GCP 服务无缝集成，从而加速无服务器应用程序的开发。

Google Cloud Bigtable

Cloud Bigtable 是 Google 的完全托管 NoSQL 大数据数据库服务。Bigtable 使用键/值映射对表进行排序来存储数据。Bigtable 可以存储数万亿行和数百万列，使应用程序能够存储 PB 级的数据。Bigtable 提供极端的可伸缩性，并自动处理数据库任务，如重启、升级和复制。Bigtable 非常适合存储大量半结构化或非结构化数据，具有低于 10 毫秒的延迟和极高的读写吞吐量。Google 的许多核心产品，如搜索、分析、地图和 Gmail，都使用了 Cloud Bigtable。

GCP 大数据和分析服务

与存储和数据库服务不同，大数据和分析服务专注于大数据处理流程：从数据摄入、存储和处理到可视化，它帮助您创建一个完整的基于云的大数据基础设施：

图 1.6 – GCP 大数据和分析服务

如前图所示，GCP 大数据和分析服务包括 Cloud Dataproc、Cloud Dataflow、BigQuery 和 Cloud Pub/Sub。

让我们简要地考察每一个。

Google Cloud Dataproc

基于 Map-Reduce 概念和 Hadoop 系统架构，Google Cloud Dataproc是 GCP 的一项托管服务，用于处理大型数据集。Dataproc为组织提供按需配置和配置不同大小数据处理集群的灵活性。Dataproc 与其他 GCP 服务兼容良好。它可以直接在云存储文件上操作或使用 Bigtable 分析数据，并且可以与Vertex AI、BigQuery、Dataplex和其他GCP服务集成。

Dataproc 帮助用户处理、转换和理解大量数据。您可以使用 Dataproc 运行 Apache Spark、Apache Flink、Presto 和 30 多个开源工具和框架。您还可以使用 Dataproc 进行数据湖现代化、ETL 流程等。

Google Cloud Dataflow

Cloud Dataflow 是 GCP 管理的服务，用于开发和执行各种数据处理模式，包括提取、转换、加载（ETL）、批量作业和流作业。Cloud Dataflow 是一个无服务器数据处理服务，使用 Apache Beam 库编写的作业在其上运行。Cloud Dataflow 执行由管道组成的作业——一系列读取数据、将其转换为不同格式并写入的步骤。数据流管道由一系列管道组成，这是一种连接组件的方式，其中数据通过管道从一个组件移动到下一个组件。当作业在 Cloud Dataflow 上执行时，该服务启动一个 VM 集群，将作业任务分配给 VM，并根据作业负载和性能动态扩展集群。

Google Cloud BigQuery

BigQuery 是 Google 提供的一项全面管理的企业数据仓库服务，具有高度可扩展性、快速响应，并针对数据分析进行了优化。它具有以下特性：

• BigQuery 支持 ANSI 标准的 SQL 查询，包括连接、嵌套和重复字段、分析聚合函数、脚本和通过地理空间分析的各种空间函数。

• 使用 BigQuery，您无需物理管理基础设施资产。BigQuery 的无服务器架构允许您使用 SQL 查询以零基础设施开销来回答大型商业问题。借助 BigQuery 的可扩展、分布式分析引擎，您可以在几分钟内查询 PB 级数据。

• BigQuery 可以无缝集成其他 GCP 数据服务。您可以使用外部表或联邦查询在 BigQuery 中查询存储的数据，或在数据所在位置运行查询，包括存储在 Google Drive 中的 GCS、Bigtable、Spanner 或 Google Sheets。

• BigQuery 通过内置的 ML、地理空间分析和商业智能等功能帮助您管理和分析数据。我们将在本书的后续部分讨论 BigQuery ML。

由于 Google BigQuery 易于使用 SQL、具有无服务器结构以及内置与其他 GCP 服务的集成，因此在许多业务案例中得到了应用。

Google Cloud Pub/Sub

GCP Pub/Sub 是一种广泛使用的云服务，用于解耦许多 GCP 服务——它实现了一个事件/消息队列管道，用于集成服务和并行化任务。使用 Pub/Sub 服务，您可以创建事件生产者，称为发布者，和事件消费者，称为订阅者。使用 Pub/Sub，发布者可以通过广播事件异步地与订阅者通信——一个发布者可以有多个订阅者，一个订阅者可以订阅多个发布者：

图 1.7 – Google Cloud Pub/Sub 服务

上述图表显示了我们在 GCP 云函数 部分讨论的示例：当一个对象被上传到 GCS 存储桶后，可以生成并发送一个请求/消息到 GCP Pub/Sub，这可以触发电子邮件通知和云函数来处理该对象。当并行对象上传的数量巨大时，Cloud Pub/Sub 将帮助缓冲/排队请求/消息，并将 GCS 服务与其他云服务（如 Cloud Functions）解耦。

到目前为止，我们已经介绍了各种 GCP 服务，包括计算、存储、数据库和数据分析（大数据）。现在，让我们来看看各种 GCP 人工智能（AI）服务。

GCP 人工智能服务

Google Cloud 中的 AI 服务是其最好的服务之一。Google Cloud 的 AI 服务包括以下内容：

• BigQuery ML（BQML）

• TensorFlow 和 Keras

• Google Vertex AI

• Google ML API

Google BQML 是基于 Google Cloud BQ 构建的，它作为一个无服务器的云大数据仓库和分析平台。BQML 使用基于 SQL 的语言从已存储在 BQ 中的数据集训练机器学习模型。TensorFlow 引入了张量的概念，并为机器学习开发提供了一个框架，而 Keras 则使用 TensorFlow 提供了一个高级结构。我们将在本书的第三部分更详细地讨论 BQML、TensorFlow 和 Keras，以及 Google Cloud Vertex AI 和 Google Cloud ML API，我们将在下一部分简要介绍。

Google Vertex AI

Google Vertex AI (cloud.google.com/vertex-ai/docs/start/introduction-unified-platform) 致力于提供一套全面管理、可扩展、安全的企业级机器学习开发基础设施。在 Vertex AI 环境中，数据科学家可以完成他们所有机器学习项目的全流程：数据准备和特征工程；模型训练、验证和调优；模型部署和监控等。它提供统一的 API、客户端库和用户界面。

Vertex AI 提供端到端的机器学习服务，包括但不限于以下内容：

• Vertex AI 数据标注和数据集

• Vertex AI 特征存储

• Vertex AI 工作台和笔记本

• Vertex AI 训练

• Vertex AI 模型和端点

• Vertex AI 管道

• Vertex AI 元数据

• Vertex AI 实验 和 TensorBoard

我们将在本书的第三部分详细检查这些内容。

Google Cloud ML APIs

Google Cloud ML APIs为用户提供 Google 预训练的机器学习模型的应用接口，这些模型是用 Google 的数据训练的。以下是一些 AI API：

• Google Cloud sight APIs，包括 Google Cloud Vision API 和 Cloud Video API。视觉 API 的预训练模型使用机器学习来理解您的图像，具有行业领先的预测准确性。它们可以用于检测对象/人脸/场景，读取手写文字，并构建有价值的图像/视频元数据。

• Google Cloud 语言 API，包括自然语言处理 API 和翻译 API。这些强大的预训练语言 API 模型使开发者能够轻松地将自然语言理解（NLU）应用于他们的应用程序，同时提供情感分析、实体分析、实体情感分析、内容分类和语法分析等功能。翻译 API 允许您检测语言并将其翻译成目标语言。

• Google Cloud 对话 API，包括语音转文本、文本转语音和 Dialogflow API。对话 API 的预训练模型能够准确地将语音转换为文本，文本转换为语音，并使开发者能够利用 Google 的尖端 AI 技术开发呼叫中心、在线语音订购系统等商业应用程序。

人工智能是计算机（或由计算机控制的机器人）执行通常由人类完成的任务的技能，因为这些任务需要人类智能。在人类历史上，从视觉发展（与寒武纪大爆发相关）到语言发展，再到工具发展，一个基本问题是，我们人类是如何进化的，我们如何教会计算机学习看、说话和使用工具？GCP AI 服务范围包括视觉服务（图像识别、检测、分割等）、语言服务（文本、语音、翻译等），还有更多。我们将在本书的后面部分了解更多关于这些服务的内容。我们确信，未来还将添加更多 AI 服务，包括手势检测工具等。

摘要

在本章中，我们首先创建了一个 GCP 免费层账户，并在云中配置了我们的虚拟机和存储桶。然后，我们研究了 GCP 组织的结构、资源层次结构和 IAM。最后，我们研究了与机器学习相关的 GCP 服务，包括计算、存储、大数据和数据分析以及 AI，以便对每个 GCP 服务有一个扎实的理解。

为了帮助您掌握 GCP 的实际操作技能，我们在附录 1“使用基本 GCP 服务实践”中提供了示例，其中我们提供了配置基本 GCP 资源的实验室，步骤详尽。

在下一章中，我们将构建另一个基础：Python 编程。我们将专注于 Python 基本技能的发展和 Python 数据库的使用。

进一步阅读

了解更多关于本章所涵盖的主题的资源如下：

• cloud.google.com/compute/

• cloud.google.com/storage/

• cloud.google.com/vpc

• cloud.google.com/products/databases

• cloud.google.com/products/security-and-identity

• cloud.google.com/solutions/smart-analytics

• cloud.google.com/products/ai

• 附录 1，使用基本 GCP 服务练习

第二章：掌握 Python 编程

在我们训练机器学习之前，我们需要教它一种语言。计算机非常擅长二进制代码，因为它们被创造出来就是要在 0 和 1 之间操作。人类发明了一种语言编译器，将高级语言（如 Python）程序编译成二进制代码，以便计算机可以运行它。Python 是一种直观的高级语言，它的语法非常简化，类似于自然语言。Python 在解决计算机编程问题中得到了广泛应用，尤其是在机器学习（ML）领域。

在本章中，我们将从一个简单的数学问题开始，展示 Python 如何直接且简洁地解决它。理解解决方案将帮助我们理解 Python 基础知识，包括变量、数据结构、条件和控制。然后，我们将介绍 Python 的数据处理包，包括用于数据操作的 NumPy 和 Pandas，以及用于数据可视化的 Matplotlib 和 Seaborn。

Python 是一种编程语言，练习是掌握这门语言的重要组成部分。在本书的附录 1中，我们提供了一个使用 Python 数据处理包的逐步指南。练习这些步骤对于掌握 Python 技能至关重要。

本章将涵盖以下主题：

• Python 的基础知识

• Python 数据库和包

在我们开始之前，让我们看看本章的先决条件。

技术要求

要遵循本章的说明，请确保您已经设置了 Google Colab，这是谷歌研究的一个产品，允许程序员通过浏览器编写和执行 Python 代码（colab.research.google.com）。Colab 非常适合机器学习和数据分析，我们将使用它来运行本章的基本 Python 代码。让我们开始吧！

Python 的基础知识

我们将通过一个简单的鸡蛋计数问题来介绍 Python 编程的基础知识。

一个大篮子里不到 2,000 个鸡蛋。假设我们每次拿两个鸡蛋一组，这样篮子里最后会剩下 1 个鸡蛋。这里我们有以下情况：

• 如果用 3 人一组，会剩下 0 人。

• 如果用 4 人一组，会剩下 1 人。

• 如果用 5 人一组，会剩下 4 人。

• 如果用 6 人一组，会剩下 3 人。

• 如果用 7 人一组，会剩下 0 人。

• 如果用 8 人一组，会剩下 1 人。

• 如果用 9 人一组，会剩下 0 人。

那么，桶里有多少个鸡蛋？

让我们看看使用 Python 编程解决这个问题的一个解决方案：

for i in range (1, 2001, 2):
      if ( ((i % 3) == 0) and ((i % 4) == 1) and ((i % 5) == 4) and ((i % 6) == 3) and ((i % 7) == 0) and ((i % 8) == 1) and  ((i % 9) == 0) ):
      print("Total number of eggs in the bucket can be %d" %i)

如您所见，我们告诉计算机尝试 1 到 2,000 之间的每个奇数（为什么？），并测试它是否满足问题中指定的所有条件。如果对于某个特定的数字，所有条件都满足，那么我们就打印出这个数字。当检查了所有奇数后，满足条件的数字就会被打印出来。这真是一件 neat 的事情！

在 Colab 上执行前面的程序会产生以下输出：

Total number of eggs in the bucket can be 1449

如果我们更仔细地检查 Python 程序，我们可以观察到以下情况：我们使用i作为变量，每次分配一个奇数，在1和2000之间，我们使用for子句构建一个循环，该循环重复检查i的值是否满足条件（if子句），如果满足则打印该值。变量及其操作、if子句和for子句是 Python 的基础。接下来，我们将检查 Python 中的这些基本概念。

基本 Python 变量和操作

编程语言使用变量。Python 变量是计算机中预留的内存位置，用于存储值——也就是说，Python 程序中的变量为计算机提供数据以进行处理。Python 中的每个值都有一个数据类型。将数据放入变量的动作称为赋值。创建变量后调用变量的动作称为使用变量。

例如，以下操作是 赋值：

表 2.1 – Python 变量赋值

以下操作是 使用变量：

表 2.2 – Python 使用变量

为了进一步了解变量的数据类型及其操作，让我们运行一些使用 Colab 的小型 Python 代码片段：

x = int(2.8)        
print(x) 
2 
z = str(3.0)    
z = float(z) 
z = int(z/2)       
z = z * 4.5
print(z)
4.5
z = z ** x
print (z)
20.25
y = float("3")     
a = (x==y)
print (a)
False
b = ((z==z) and (a != x))
print (b)
True

请在此处稍作停留，确保您理解了前面的代码片段是如何执行以获得结果的。

对于 Python 变量，我们可以使用数学运算对它们进行操作。以下表格列出了 Python 变量的算术运算：

表 2.3 – Python 算术运算

以下表格列出了 Python 变量的布尔运算：

表 2.4 – Python 布尔运算

以下表格列出了 Python 变量的逻辑运算：

表 2.5 – Python 逻辑运算

现在我们已经介绍了 Python 变量及其基本操作，让我们看看 Python 的基本数据结构和控制操作。

基本 Python 数据结构

Python 有五种基本数据类型：

• 数字

• 字符串

• 列表

• 元组

• 字典

由于我们已经涵盖了数字和字符串，因此在这里我们将介绍 列表、元组和字典：

• 一个 [ ]。以下是一个示例：

  ints = [10, 20, 30, 40]
  words = ["flower", "soil", "water"]
  mix = ["flower", -3.2, True, 6]  
  empty_list = []
  floats = [4.7, -6.0, 0.22, 1.6]
  

列表的基本操作如下表所示：

表 2.6 – Python 列表操作

• 一个 ()。以下是一个示例：

  coordinates = (1, 2, 3)
  

• 一个 {}，字典中的键值对由逗号（,）分隔。每个键与其值由冒号（:）分隔。以下是一个示例：

  person = {'name': 'Lini', 'year': 1989, 'expertise': 'data analytics'}
  

Python 条件和循环

Python 程序需要根据条件做出决策，如下所示：

• if（条件）else（动作）

• while（条件）do（动作循环）

• for（条件）do（动作循环）

正如你在鸡蛋计数程序中看到的，它包含一个for循环和if语句：

for i in range (1, 2001, 2):
    if ( ((i %for  3) == 0) and ((i % 4) == 1) and ((i % 5) == 4) and ((i % 6) == 3) and ((i % 7) == 0) and ((i % 8) == 1) and  ((i % 9) == 0) ):
    print («Total number of eggs is %d» %i)

通过for循环和if语句解决了问题。这些控制语句管理 Python 程序中的逻辑流程。

Python 函数

Python 函数在程序中有两个部分：函数定义和函数调用。首先定义一个函数，然后调用定义好的函数。让我们通过一个例子来解释函数定义和调用：

• 问题：找出 1 到 100 之间的所有质数

• 解决方案：使用 Python 函数

下面是如何使用函数定义和调用来解决给定问题的示例：

1. 函数 1接受一个数字并检查它是否是质数：

   def Prime(Number):
   for i in range(2, (int(math.sqrt(Number))+1)):
              if(Number % i == 0):
                     return 0
              else:
                     continue
              return 1
   

2. 函数 2查找并返回a和b整数之间的所有质数。对于a和b之间的每个整数，它通过调用函数 1来检查它是否是质数。如果是，则将其添加到列表中。最后，返回列表：

   def PNlist(a,b):
              list=[]
             for Number in range (a, b):
                if (Prime(Number)==1):
                    list.append(Number)
             return list
   

3. main()程序查找并返回1到100之间的所有质数：

   list1=PNlist(1,100)
   print(list1)
   

如你所见，当计算机执行主程序时，它将调用函数 2，PNlist(1,100)，来检查1到100之间的数字：对于每个数字，它将调用函数 1，Prime(number)，来查看它是否是质数——如果是，它将被放入列表中。最后，main()程序打印出质数列表。

在 Python 中打开和关闭文件

以下 Python 代码打开一个输入文件并从用户输入中读取：

1. 只读方式打开名为“lifeguards.in”的文件。

2. 读取文件中的一行。

3. 将读取的文本转换为整数：

    f1=open("lifeguards.in", "r")
    n1=f1.readline()
    n=int(n1)
    f1.close
   

以下 Python 代码块计算答案，将其写入输出文件，并关闭文件：

  answer=n*(n+1)/2
  f2=open("lifeguards.out", "w")
  f2.write(str(answer))
  f2.close

现在我们已经了解了 Python 的基础知识，让我们利用我们迄今为止学到的知识和技能来解决一个有趣的问题。

一个有趣的问题

在本节中，我们将使用我们迄今为止学到的基本 Python 知识和技能来解决美国计算机奥林匹克竞赛问题（来源：www.usaco.org/index.php?page=viewproblem2&cpid=784）。

农夫约翰开设了一个游泳池，并雇佣了N头牛作为救生员，每头牛在一天中的某个连续时间段内值班。为了简单起见，游泳池每天从t=0到t=1000开放，每个班次可以用两个整数来描述——开始和结束时间。例如，一个救生员从t=4开始到t=7结束，覆盖了三个时间单位。不幸的是，约翰超出了预算，必须解雇一头牛。剩余的救生员班次能覆盖的最大时间是多少？如果至少有一名救生员在场，则时间区间被覆盖。让我们看看：

• 输入

输入的第一行包含N (1≤N≤100)。接下来的N行描述了救生员，以两个介于0和1000之间的整数来表示救生员的工作开始/结束点。所有这些端点都是唯一的。不同救生员的工作时间可能重叠。

• 输出

写一个数字，指定如果农夫约翰发射1个救生员，还能覆盖的最大时间量：

SAMPLE INPUT:
3
5 9
1 4
3 7
SAMPLE OUTPUT:
7

让我们看看以下图表来理解这个问题：

图 2.7 – 理解示例输入和输出

上述图表显示了示例输入和输出。在这里，我们可以看到有三个救生员，他们的时间覆盖范围分别是 5-9，1-4 和 3-7。如果我们移除第一个救生员，剩余的覆盖范围将是 1-7，即 6。如果我们移除第二个救生员，剩余的覆盖范围将是 3-9，等于 6。如果我们移除第三个救生员，剩余的覆盖范围将是 1-4 和 5-9，等于 7。所以，逐个移除一个救生员时的最大覆盖范围是max(6,6,7)=7。

理解这个示例有助于我们思考解决方案。我们需要通过逐个移除一个救生员来比较剩余的覆盖范围，找出最大的覆盖范围。最简单的方法是使用穷举法和 Python 列表。以下是一个使用 Python 的解决方案：

1. 声明/初始化变量和数组：

   start=[0 for i in range(1001)]
   end=[0 for i in range(1001)]
   cover=[0 for i in range(1001)]
   cover1=[0 for i in range(1001)]
   

2. 打开输入文件并读取输入数据：

   f1 = open("lifeguards.in", "r")
   n=f1.readline()
   n=int(n)
   

3. 读取数据并将其分配给变量（start[i]和end[i]是救生员i的工作开始/结束时间）：

   for i in range(1, n+1):
     a,b=f1.readline().split()
     a=int(a)
     b=int(b)
     start[i]=a
     end[i]=b
   

4. 使用一个新的列表来记录时间j的总救生员覆盖范围：

    for j in range (a, b):
        cover[j] += 1
    f1.close()
   

5. 逐个移除一个救生员，比较最大覆盖范围，并获取最大值：

   answer=0
   for i in range (1, n+1):
        for j in range (1, 1000):
        cover1[j]=cover[j]
        max = 0
        for j in range (int(start[i]), int(end[i])):
         cover1[j] -= 1
    for k in range (1, 1000):
             if (cover1[k] > 0): max=max+1
         if (answer < max):
         answer = max
   

6. 打开输出文件，将其中的输出数据写入，然后关闭文件：

   f2 = open("lifeguards.out", "w")
   f2.write(str(answer))
   F2.close()
   

尽管这个问题有多个解决方案，但这个解决方案展示了处理问题的简单和逻辑方法。它有助于 Python 初学者跟随和学习解决问题所需的逻辑和技能。

Python 数据库和包

如我们之前提到的，Python 有五种标准数据类型：数字、字符串、列表、元组和字典。使用这些数据结构，Python 可以处理许多任务。为了扩展其数据操作和可视化的能力，创建了 Python 库和包。我们将简要介绍四个库：NumPy、Pandas、Matplotlib和Seaborn。

NumPy

NumPy 代表数值 Python。它是 Python 的一个基础库，是一个通用的数组处理包。NumPy 在基本和高级数组操作方面非常出色。它用于处理存储相同数据类型值的数组。

Pandas

Pandas 被认为是可用的最强大和灵活的开源数据分析和管理工具。它是一个针对数据操作和分析进行优化的 Python 库。特别是，它提供了用于操作多维数据数组的结构和操作。Pandas 包含 Series 和 DataFrame 数据结构。Series 数据结构用于存储 1D 数组（或向量）的数据元素，而 DataFrame 是用于存储和操作 2D 数组的 Pandas 数据结构。在实践中，我们通常将其视为电子表格。Pandas 还有一套强大的绘图函数，我们也将用于数据集可视化。Pandas 的绘图功能可以在 plotting 模块中找到。

Matplotlib

Matplotlib 是用于 Python 数据可视化的图形包。它是 Python 编程语言及其数值数学扩展 NumPy 的绘图库，并且与 NumPy 和 Pandas 集成良好。

Seaborn

在 Matplotlib 的基础上，Seaborn 是一个用于数据可视化和探索性数据分析的开源 Python 库。Seaborn 与 Pandas DataFrames 一起工作，并支持内置的 Python 类型，如列表和字典。大多数 Seaborn 函数都支持来自 Pandas 和 NumPy 库的对象。

摘要

在本章中，我们回顾了 Python 基础知识，包括变量、数据结构、条件和循环语句，以及各种 Python 数据库。理解本章中的 Python 代码片段并完成 附录 2，使用 Python 数据库练习 中的示例至关重要，我们在其中提供了示例来帮助您逐步练习使用 Python 数据库。通过这样做，您可以使用 Google Colab 开发 Python 代码。

现在我们已经建立了 GCP 和 Python 的基础，是时候总结本书的 第一部分 了。在 第二部分 中，我们将探讨机器学习过程，包括问题定义、数据准备和特征工程、机器学习模型开发、神经网络和深度学习。在下一章中，我们将探讨机器学习问题定义。

进一步阅读

要了解更多关于本章所涵盖的主题，请参阅以下资源：

• Colab

• Colab

• Python 编程语言

• 2021 年数据科学领域前 10 个 Python 库

• 附录 2，使用 Python 数据库练习

第二部分：介绍机器学习

本部分介绍了机器学习（ML）的概念。我们首先介绍机器学习过程的准备工作，包括机器学习问题定义和数据准备。我们深入探讨机器学习过程，包括平台准备、数据集划分、模型训练、验证、测试和部署。然后，我们介绍现代机器学习概念，如神经网络、深度学习、损失函数、优化算法、激活函数等。我们进一步讨论了几种神经网络模型及其商业应用案例。

本部分包括以下章节：

• 第三章，准备机器学习开发

• 第四章，开发和部署机器学习模型

• 第五章，理解神经网络和深度学习

第三章：准备机器学习开发

在本书的第二部分中，我们将检查机器学习过程。我们将从准备工作开始，包括机器学习问题界定来定义机器学习问题；数据准备和特征工程来准备数据；然后是机器学习模型开发阶段，包括模型训练、模型验证、模型测试和模型部署。我们将以神经网络和深度学习结束第二部分。

在本章中，我们将讨论两个机器学习准备任务：机器学习问题界定和数据准备。我们将针对我们正在解决的问题提出以下问题：

• 业务需求是什么？

• 机器学习是解决问题的最佳方式吗？

• 问题的输入和输出是什么？

• 我的数据在哪里？

• 我如何衡量机器学习解决方案的成功？

• 数据准备好了吗？

• 我如何收集我的数据？

• 我如何转换和构建我的数据？

• 我如何为机器学习模型选择特征？

确定业务需求、理解问题及其输入/输出、建立业务成功指标、在模型训练和部署之前收集、转换和构建高质量数据集非常重要。通过这个过程，我们将学习和培养以下技能：

• 定义和理解业务问题

• 将其转化为机器学习问题

• 定义和衡量业务问题的成功

• 定义高质量数据集

• 收集数据

• 转换和构建数据

• 特征工程

在我们阅读本章时，让我们牢记这些问题和技能。

从业务需求开始

典型的机器学习过程首先从定义业务需求开始。按照以下步骤定义问题的业务需求：

1. 在所有利益相关者中，明确定义您的机器学习解决方案旨在实现的业务成果。例如，对于预测机器学习问题，我们需要定义一个业务可以接受的准确度范围，并且所有利益相关者都同意。

2. 明确定义机器学习问题的数据来源。所有机器学习项目都基于大量数据。您需要明确定义可靠的数据来源，包括训练数据、评估数据、测试数据和定期更新的数据流。

3. 明确定义机器学习模型更新的频率（因为数据分布会随时间漂移），以及维护生产在模型更新时间内的策略。

4. 明确定义机器学习产品或项目的财务指标。了解任何限制，如资源可用性和预算规划等。

5. 明确定义问题的规则、政策和法规。

让我们看看一个问题和业务需求的例子：

• 示例 1：一家名为 Zeellow 的房地产公司在美国买卖房产业务做得很好。由于业务性质，准确预测房价对 Zeellow 来说至关重要。在过去几年中，他们积累了大量美国房屋的历史数据。

在这里，业务成果是准确预测美国房价。业务利益相关者一致认为，超过 2% 的预测误差是不可接受的。数据源定义为内部历史房产数据库。由于数据库更新，模型需要每月更新。有两个数据科学家和两个数据工程师全职从事该项目，并且已经提供了足够的资金。关于房屋数据和机器学习问题没有规定。

定义机器学习问题

在我们确定了业务需求之后，我们需要通过识别问题的特征和目标来定义问题。对于示例 1，房价是目标，特征是影响房价的房屋属性，如位置、房屋大小（总面积）、房屋年龄、房屋的卧室和浴室数量等。表 3.1 展示了一个小样本数据集：

表 3.1 – 示例 1 数据集

然后定义问题为在特征和目标之间建立模型并发现它们之间的关系。在问题定义过程中，我们将更好地理解问题，决定机器学习是否是解决问题的最佳解决方案，以及问题属于哪个类别。

机器学习是最好的解决方案吗？

面对问题时，我们首先需要做的是为问题选择最佳的建模/解决方案。例如，给定一个物理对象的初始位置和速度、其质量和作用在其上的力，我们如何精确预测其在任何时间 t 的位置？对于这个问题，基于经典力学世界中牛顿定律的传统数学模型，比任何机器学习模型都要好得多！

虽然科学建模提供了预测目标和特征之间的数学关系，但有许多问题很难建立数学模型，甚至不可能建立，机器学习可能是解决这些问题的最佳方式。我们如何知道机器学习是否是解决给定问题的最佳方式？在判断机器学习是否是潜在的良好解决方案时，需要检查以下条件：

• 特征和预测目标之间存在一种模式。对于示例 1，我们知道房价将与房屋特征（如位置、总面积、年龄等）相关，并且房价与其特征之间存在模式。

• 现有的模式或关系无法用数学或科学方法建模。对于示例 1，房价和特征之间的关系无法用数学公式表示。

• 可用的优质数据量很大。对于示例 1，Zeellow 为美国房屋积累了大量历史数据，包括价格和其特征。

• 在示例 1中，Zeellow 需要预测房屋价格。显然，房价和房屋特征之间存在关系，但建立数学模型来描述这些关系非常困难。由于我们有足够的历史数据，机器学习可能是解决该问题的有效方法。

让我们看看更多示例，看看机器学习是否是它们的最佳解决方案：

• 示例 2：Zeellow 抵押贷款是 Zeellow 的子公司，是一家美国的抵押贷款业务。他们还积累了大量关于抵押贷款申请人的历史数据，并试图自动化对新申请的批准或拒绝决策过程。

• 示例 3：Zeellow 评估是 Zeellow 的子公司，他们在房屋签订合同时评估现有房屋的价格。一个很好的近似方法是查看类似房产的定价情况，这会导致房产的分组。

在检查这两个问题及其条件后，我们可以决定机器学习是否是解决问题的方法。进一步地，我们将查看机器学习问题的类别以及我们的三个示例属于哪种类型。

机器学习问题类别

机器学习问题可以分为几个类别。对于示例 1，Zeellow 需要预测房价，这是一个连续值，与示例 2中机器学习需要预测抵押贷款申请的批准（是）或拒绝（否）相比。输出连续值的机器学习问题称为回归，而输出离散值（两个或更多）的问题称为分类。如果有两个输出（是和否），则称为二元分类。如果有超过两个输出，则称为多类分类。

在示例 1和示例 2中，我们让机器从带有结果的现有数据集中学习。示例 1的数据集是过去几年已售出的房屋数据，包括房屋位置、卧室和浴室数量、房屋年龄和售价。示例 2的数据集包括抵押贷款申请人的性别、年龄、收入、婚姻状况等，以及申请是否被批准或拒绝。由于这两个示例的输入都是标记的，因此它们被称为监督学习。在示例 1中，房屋的位置、卧室和浴室数量以及房屋年龄等输入数据被称为特征，因为它们反映了数据集的属性（特征）。

无监督学习问题，另一方面，输入没有标签。对于示例 3，Zeellow 评估需要将房屋分成不同的组，并且每个组都有相似的特征。这里的重点不是房价，而是要识别数据中的有意义模式并将房屋分成组。由于我们没有标记数据集，这是一个无监督学习问题。

另一种机器学习问题是强化学习（RL）。在强化学习中，你不需要收集带有标签的例子。你设置模型（代理）和奖励函数，当代理完成一个任务时奖励它。通过强化学习，代理可以快速学会如何超越人类。更多详情可以在维基百科页面找到（en.wikipedia.org/wiki/Reinforcement_learning）。

机器学习模型的输入和输出

在机器学习问题中，输入通常是数据集，包括各种数据格式/媒体，如数值数据、图像、音频等。输入数据集非常重要，将决定机器学习模型的好坏。

对于监督学习，使用标记数据来训练模型，这是一个代表机器从训练数据中学到什么的软件。监督学习的输入是标记的特征和目标的数据集，模型通过比较标记的目标值与模型输出以找到错误来学习。错误是我们想要优化的。注意，我们指的是错误的优化，而不是错误的极小化。换句话说，将错误最小化到零可能不会生成最好的模型。

在监督学习中，回归模型的输出是一个连续的数值，而分类模型的输出是一个离散的值，表示一个类别（二分类中的是/否）。

对于无监督学习，输入数据没有标签，通常的目标是找到输入数据的模式并将它们分组到不同的类别中，称为聚类或分组。

对于强化学习，输入是一个状态，输出是机器学习执行的动作。在输入和输出之间，有一个函数，它以状态作为输入并返回一个动作作为输出。

测量机器学习解决方案和数据准备情况

在我们定义问题并得出结论，认为机器学习可能是解决问题的潜在好方法之后，我们需要建立一个衡量问题解决方案和它是否准备好生产部署的方法。对于示例 1，我们需要就房屋预测误差的接受范围达成共识，并且可以使用机器学习模型在生产环境中使用。

机器学习模型性能测量

为了评估机器学习解决方案的性能，我们使用机器学习指标。对于回归模型，有三个指标：均方误差、平均绝对误差和 r 平方。对于分类模型，我们使用混淆矩阵。我们将在接下来的章节中更详细地讨论这一点。

机器学习解决方案是否已经准备好部署？我们需要回到机器学习问题框架中模型的原始业务目标：

• 对于 Zeellow 来说，预测房价以 95%的准确性是否足够好？

• 对于 Zeellow 抵押贷款，我们是否允许以 95%的置信度做出决策？

• 对于 Zeellow 评估，我们能否以 95%的准确性将房屋分类到正确的组别？

在我们使用测试数据集评估了机器学习模型并确认模型达到了业务要求后，我们就可以准备将其部署到生产环境中。

数据准备就绪

数据在机器学习过程中扮演着如此重要的角色，以至于数据的质量对模型性能有着巨大的影响，这就是所谓的垃圾输入，垃圾输出。一个机器学习模型的准确性依赖于许多因素，包括数据集的大小和质量。认为数据越多，模型准确性越高的观点并不总是正确的。在实时情况下，获取大量干净、高质量的数据是一个巨大的挑战。通常在一个机器学习项目中，我们会花费大量时间来收集和准备数据集。根据我们需要解决的机器学习问题，有几种收集数据的方法和来源。例如，我们可以考虑以下几种：

• 公司收集的历史数据，如用户数据和媒体数据

• 来自研究机构和政府机构公开可用的数据

我需要多少数据才足够用于我的机器学习模型，我们如何衡量我们数据的质量？这取决于你想要解决的机器学习问题的类型。作为问题框架过程的一部分，我们需要检查并确保我们有足够的高质量数据来构建机器学习解决方案。接下来，我们将更详细地讨论数据准备和特征工程。

数据收集

数据收集是指收集源数据并将其存储在中央安全位置。在数据收集阶段，我们试图回答以下问题：

• 问题的本质是什么，我们是否有适合它的正确数据？

• 数据在哪里，我们是否有权访问数据？

• 我们能做些什么来将所有数据整合到一个中央存储库中？

• 我们如何保护中央数据存储库？

这些问题在任何机器学习项目中都至关重要，因为在实际业务中，数据通常分布在许多不同的异构源系统中，将所有源数据汇集在一起形成一个数据集可能会涉及巨大的挑战。

一种常见的提取、转换和加载（ETL）数据收集和整合过程包括以下步骤：

1. 提取：从各种来源将数据拉到一个单一的位置。

2. 转换：在数据提取和整合过程中，我们可能需要更改数据格式，修改一些数据，删除重复项等。

3. 加载：数据被加载到一个单一存储库中，例如 Google Cloud Storage 或 Google BigQuery。

在这个 ETL 过程中，我们还需要解决数据的大小、质量和安全问题：

• 数据量：我们需要多少数据才能获得有用的机器学习结果？虽然答案取决于机器学习问题，但经验法则是训练数据集将是模型可训练参数的几倍。例如，一个典型的回归问题可能需要比特征多十倍的数据观测值。一个典型的图像分类问题可能需要成千上万张图像来创建一个高精度的图像分类器。一般来说，使用大型数据集训练的简单模型比使用小型数据集的复杂模型表现更好。

• 数据质量：这可以包括以下内容：

  • 可靠性：数据来源是否可靠？数据集是否正确标记？数据集是否经过适当过滤？是否存在重复或缺失值？

  • 特征表示：数据集是否表示有用的机器学习特征？是否存在任何异常值？

  • 训练数据和生产数据的一致性：训练数据集和生产数据集之间是否存在任何偏差？

• 数据安全：数据是否安全？我们需要对数据进行加密吗？数据集中是否存在任何个人身份信息（PII）？访问数据集是否有任何法律或监管要求？

数据收集并存储在中央安全仓库后，我们需要构建和转换它为正确的格式，以便用于机器学习模型训练。我们将在下一节讨论这个问题。

数据工程

数据工程的目标是确保数据集代表真实的机器学习问题，并且具有适合机器学习模型训练的正确格式。通常，我们使用统计技术来采样、平衡和缩放数据集，并处理数据集中的缺失值和异常值。本节涵盖以下内容：

• 使用子数据集采样数据

• 平衡数据集类别

• 数据转换

让我们从数据采样和平衡开始。

数据采样和平衡

数据采样是一种统计分析技术，用于选择、操作和分析较大数据集中的一个代表性子集。数据采样在数据构建中扮演着重要角色。在采样数据时，你需要非常小心，不要引入偏差因素。更多详情请参阅developers.google.com/machine-learning/data-prep/construct/sampling-splitting/sampling。

一个分类数据集有超过两个数据集类别。我们称构成集合大部分的类别为多数类别，而构成小比例的类别为少数类别。当数据集有偏斜的类别比例——即少数类别的比例显著低于多数类别的比例时，它是一个不平衡的数据集，我们需要使用称为下采样和增加权重的统计技术来平衡它。让我们考虑一个欺诈检测数据集，其中 1 个是正例，200 个是负例。由于正例的比例如此之小，模型训练过程将不会反映真实问题。在这种情况下，我们需要分两步处理数据集：

• 下采样：从主导类中提取数据示例以平衡类别。以 50 的下采样因子，下采样后的比例将是 40:1。

• 增加权重：在机器学习模型训练期间，将主导类权重增加相同的 50 倍（与下采样因子相同）。

一些机器学习库已经提供了内置功能来简化这个过程。有关技术和为什么执行前面的步骤的更多详细信息，请参阅developers.google.com/machine-learning/data-prep/construct/sampling-splitting/imbalanced-data。

数值值转换

对于具有覆盖不同范围（例如，抵押贷款申请批准机器学习模型中的年龄特征）的数值特征的数据集，强烈建议规范化数据集，因为它将帮助梯度下降等算法收敛。规范化数据的一些常见方法如下：

• 缩放到一个范围

• 裁剪

• 对数刻度

• 桶划分/分箱

缩放到一个范围

缩放到一个范围规范化是将浮点特征值从其自然范围（例如，0-90 岁的年龄范围）转换为标准范围（例如，0 到 1，或-1 到+1）。当你知道数据的近似范围（上限和下限）并且数据在该范围内近似均匀分布时，这是一个很好的规范化实践。例如，大多数年龄值都在 0 到 90 之间，范围内的每个部分都有大量的人，因此规范化年龄值是一种常见的做法。

特征裁剪

特征裁剪将所有超过（或低于）一定值的特征值限制为固定值。如果你的数据集中包含极端异常值，特征裁剪可能是一个好的做法。例如，你可以将所有超过 80 的温度值裁剪为正好 80。特征裁剪可以在其他规范化之前或之后应用。

对数刻度

对数缩放计算特征值的对数，从而将广泛的数据范围压缩到狭窄的范围。当数据值中有许多点而其他值很少时，对数缩放成为一种好的转换方法。例如，电影评分是对数缩放的良好商业用例，因为大多数电影只有很少的评分，而少数电影有大量的评分。

桶化

桶化也称为分箱。它使用一组阈值将数值特征转换为类别特征。一个很好的例子是将房价转换为低、中、高类别，以更好地建模。

类别值转换

类别值是离散值，它们之间没有有序关系，每个值代表一个类别。如果类别数据没有顺序，例如，一个颜色特征具有红色、绿色和蓝色等值，并且没有对类别有任何偏好，如果你将1、2和3分别分配给代表红色、绿色和蓝色，那么模型可能会将蓝色解释为比红色更重要，因为它具有更高的数值。我们通常将非序数数据编码到多个列或特征中，称为独热编码。图 3.2显示了颜色特征的独热编码转换 – 红色是 100，蓝色是 010，绿色是 001：

图 3.2 – “颜色”特征的独热编码

独热编码将非序数类别值转换为数值，而不引入任何序数偏差。它在机器学习数据转换中得到了广泛应用。

缺失值处理

在准备数据集时，我们经常看到缺失数据。例如，你的数据集中的一些列可能因为数据收集错误而缺失，或者没有收集到特定特征的某些数据。缺失数据可能会使准确解释特征与目标变量之间的关系变得困难，处理缺失数据是数据准备中的重要步骤。

根据缺失数据的原因、总数据集大小以及缺失值的比例，我们可以选择删除整个特征或填充缺失值。例如，如果某行或某列有大量缺失值，删除整个行或列可能是一个可行的选项。如果缺失值在数据集中随机分布，并且只占其行或列的一小部分，那么填充可能是一个更好的选择。对于类别变量，我们通常可以用平均值、中位数或最频繁出现的值来替换缺失值。对于数值或连续变量，我们通常使用平均值或中位数来填充。有时，我们也会遇到空值或零，但应该谨慎处理，因为零可以是列中的一个值，而 ETL 管道会将所有缺失值替换为零。

异常值处理

通常，我们也会看到异常值——这些数据点在数据集的其他值中距离异常遥远。异常值可能会使模型更难准确预测，因为它们会将值偏离与该特征相关的其他更正常值。根据异常值的原因，你可能想要清理它们，或者将它们转换以丰富你的数据集（一些算法具有内置的函数来处理异常值）：

• 删除异常值或填充异常值：如果你的异常值基于人工错误，例如输入数据错误

• 转换异常值：通过对值取自然对数来减少异常值对整体数据集的影响

通过之前展示的数据构建和转换过程，数据集已准备好。现在，是时候进行下一步：检查和选择特征（影响模型目标的变量）——这个过程称为特征工程。

特征工程

特征工程是选择和转换 ML 建模中最相关特征的过程。它是 ML 学习过程中最重要的步骤之一。特征工程包括特征选择和特征合成（转换）。

特征选择

对于在初始阶段提取了大量特征的 ML 问题，特征选择用于减少这些特征（输入变量）的数量，以便我们可以专注于对模型预测目标变量最有用的特征。在你为问题提取特征之后，你需要使用特征选择方法来选择最适合模型训练的特征。根据是否需要 ML 训练，你可以使用两种主要的特征选择方法——过滤方法和包装方法：

• 过滤方法使用统计技术来评估和评分每个输入变量与目标变量之间的关系。这些评分用于比较特征并决定将用于模型中的输入变量。

• 包装方法创建具有不同输入特征子集的多个模型，并执行模型训练和比较它们的性能。根据性能指标，将选择最适合性能的模型的特征子集。包装方法需要在不同的子集上进行 ML 训练。

特征合成

合成特征是通过算法创建的，通常是通过使用加法、减法、乘法和除法等算术运算将真实特征组合起来来训练机器学习模型。特征合成为数据模式提供了深刻的见解，并有助于某些 ML 问题的模型训练。

在数据收集、构建和转换以及特征工程之后，我们的数据已准备好进入下一阶段——模型开发。

摘要

在本章中，我们讨论了机器学习过程的准备工作。从业务需求开始，你需要理解问题并判断机器学习是否是最佳解决方案。然后你定义机器学习问题，设置性能测量，并确定用于机器学习建模的数据，以确保我们有一个高质量的数据集。

数据扮演着如此重要的角色！我们也在本章中讨论了数据准备和特征工程。从数据收集和构建到数据转换、特征选择和特征合成，数据管道为机器学习模型训练准备数据集。掌握这些数据准备和特征工程技能将使我们深入了解数据，并有助于模型开发。在下一章中，我们将讨论机器学习模型开发过程，从模型训练和验证到模型测试和部署。

进一步阅读

为了深入了解本章所学内容，你可以参考以下链接：

• developers.google.com/machine-learning/problem-framing

• developers.google.com/machine-learning/data-prep

第四章：开发和部署机器学习模型

在上一章中，我们讨论了机器学习过程的准备阶段，包括问题界定和数据准备。在界定问题并拥有干净的数据集后，就到了开发并部署机器学习模型的时候了。在本章中，我们将讨论模型开发过程。我们将从模型数据输入和硬件/软件平台设置开始，然后专注于模型开发流程，包括模型训练、验证、测试，最后部署到生产环境。我们的重点是理解基本概念及其背后的思维过程，并通过实践加强知识和技能。本章涵盖了以下主题：

• 分割数据集

• 构建平台

• 训练模型

• 验证模型

• 调整模型

• 测试和部署模型

• 使用 scikit-learn 进行实践

在附录 3中，我们提供了使用 Python 数据科学包 scikit-learn 进行机器学习模型开发实践示例。

分割数据集

通过数据准备过程，我们已经获得了一个可用于模型开发的数据集。为了避免模型欠拟合和过拟合，最佳实践是随机但按比例地将数据集分割成基于模型开发过程的独立子集：训练数据集、验证数据集和测试数据集：

• 训练数据集：用于训练模型的子集。模型将从训练数据集中学习。

• 验证数据集：用于验证训练模型的子集。模型超参数将基于验证结果进行优化。

• 测试数据集：用于在生产部署前评估最终模型的子集。

常规做法是使用 80%的数据作为训练子集，10%用于验证，10%用于测试。当你拥有大量数据时，你可以将其分为 70%的训练，15%的验证和 15%的测试。

准备平台

虽然数据输入对模型质量有重大影响，但我们训练/验证/测试模型的硬件/软件平台也会影响模型和开发过程。选择正确的平台对于机器学习过程非常重要。

虽然当然，你可以选择使用台式机或笔记本电脑进行机器学习模型开发，但鉴于云计算提供的巨大优势（自助配置、按需、弹性、可扩展性，全球规模），使用云平台是一种推荐的做法。云计算提供了许多工具，以协助数据科学家进行数据准备和模型开发。

在云服务提供商中，Google Cloud Platform 为数据科学家提供了出色的机器学习平台：灵活、弹性、性能强大，从端到端。本书的第三部分将讨论更多关于 Google Cloud ML 平台的具体细节。

现在我们已经准备好了数据集和机器学习平台，让我们直接进入机器学习模型开发过程，从模型训练开始。

训练模型

使用训练数据子集，在平台上，我们训练机器学习模型来学习目标变量和特征之间的关系。机器学习模型训练是一个迭代过程：它从一个具有初始参数的假设模型开始，并继续学习过程，直到模型与训练数据集拟合。图 4.1展示了机器学习模型训练的一个示例过程，其中我们选择了线性回归模型（z=wx+b）并选择了初始参数（w和b）。我们计算模型的预测误差——模型输出与实际数据标签之间的差距——这一步称为前向传播。如果误差没有优化（准确率不在指定的范围内），我们需要回退并调整模型的参数（w和b）——这一步称为反向传播。然后我们将向前重新计算误差。这个模型训练过程会重复前向传播、反向传播和前向传播的步骤，直到我们得到一个在预期范围内产生预测误差的模型，即满足业务目标定义的准确率。然后模型训练过程就完成了。

图 4.1 – 机器学习模型训练过程

如您可能已注意到，在先前的例子中，我们选择了线性模型（z=wx+b）。在现实生活中，我们在选择机器学习模型时，通常会利用领域知识和某些假设。这可能是一个线性模型、多项式模型，甚至只能用神经网络表达的东西。

接下来，我们将回顾上一章（示例 1、2和3）中提出的样本机器学习问题，讨论线性回归和二元分类，并将它们扩展到高级模型和算法。

线性回归

在第三章**，准备机器学习开发中，我们讨论了示例 1：Zeellow 需要从他们的历史数据集中准确预测房价。由于问题的输入是有标签的，这是一个监督学习问题，而且输出是一个连续值，因此这是一个回归问题。

从数学的角度来看，这是一个典型的寻找目标变量和特征之间函数（关系）的问题，而我们唯一拥有的就是样本数据集。那么，我们如何找出这个函数呢？让我们检查一个简单的示例 1数据集：在一定时间段内、某一地点的 10 套房屋的销售价格。样本数据集显示在表 4.2中。

表 4.2 – 示例 1 住房数据集

与目标（房价）相关的特征有多个。我们将首先检查房价与房屋的一个特征之间的关系。让我们看看房屋销售价格（目标，用 y 表示）和房屋面积（特征，用 x 表示），从而引出一元回归的主题。

单变量回归

如您从 Table 4.2 中所见，样本训练数据集有 10 行，我们需要找到一个函数 y=f(x)，它能最好地描述目标 y 与特征 x 之间的关系。自然，我们将使用图表来可视化它们的关系。如果我们把数据集中的 10 个项目放入坐标系中，我们得到 Figure 4.3。如您所见，有 10 个点分布在第一象限，我们需要对房价（y）与房屋面积（x）之间的关系做出假设。它是线性函数（如图线 l1 和 l2 所示）还是二次函数（曲线 d1 所示）来表示 y 与 x 的关系？显然，d1 不适用，因为我们直观地知道当 x 增加时，y 也会增加。现在，在 l1 和 l2 中，我们选择哪一个？这变成了一元线性回归问题：找到最佳拟合线 y=wx+b（参数为 w 和 *b）以最好地拟合训练数据集。

Figure 4.3 – Linear regression

我们的目标是找到最适合现有数据的函数，并预测新数据的最优目标值（最接近实际值）。你如何定义“最佳拟合”？为了回答这个问题，我们提出了数学概念“成本函数”来衡量模型的表现：预测值与实际值之间的差异或距离。

有几种方法可以衡量预测值与实际值之间的差异。用坐标表示第 i 个数据点的 (xi, yi)；也就是说，yi 是 xi 的实际值，而 是 xi 的预测值。然后可以将成本函数定义为以下之一（这里 N 是样本数量，对于我们的 example 1，N=10）：

• 平均绝对误差（MAE）是预测值与真实值之间绝对差分的总和：

• 均方误差（MSE）是预测值与真实值之间平方差分的总和：

虽然 MSE 和 MAE 都可以用作成本函数，但它们之间有一些区别：最小化 MAE 倾向于在每个点上减少差距，可能导致某些值变为零（从而删除一些特征并使模型变得稀疏）。最小化 MSE 将避免大的差距，但不会导致零差距。

现在问题变成了：我们如何选择合适的参数 (w, b) 以使 MSE 或 MAE 最小化？我们将使用 MSE 作为成本函数，我们的重点是找到合适的参数 (w, b)，以便在训练数据集上使成本函数 MSE 最小化。为此，我们引入了 梯度下降 的概念。

梯度下降

从数学的角度来看，如果我们只用一个变量 w 简化 MSE 函数，那么图表将类似于 图 4.4. 从数学上，我们可以通过使用导数找到最小化 f(w) 的值 *w*，因为 f(w) 在 w 处的导数为零。

从计算机编程的角度来看，我们需要使用一个称为梯度下降的算法来找到最佳点 w**。对于单一变量，梯度是成本函数的导数。从初始点 (w0, f0) 开始，我们希望找到下一个点 (w1, f1)，其中 f1 = f(w1)* 小于 f0=f (w0)。由于 f(w) 在 w0 处的导数是负的，而我们想最小化 f，因此从 w0 到 w1 的移动方向将是增加的，移动幅度（也称为步长或学习率）需要调整，以确保它既不会太小导致许多步骤才能达到 *w，也不会太大导致偏离 *w。

图 4.4 – 梯度下降

图 4.4 还显示了梯度下降算法的步骤：从初始点 (w0, f0) 移动到 (w1, f1)，到 (w2, f2)，直到达到优化点 (w3, f3) = (w, f)。请注意，对于非凸成本函数，起始点很重要，因为对于 w 存在多个最小值，如图 4.5 所示。

图 4.5 – 非凸成本函数

梯度下降算法允许我们通过反复从 (wi, fi) 移动到 (wi+1**, fi+1**) 来找到最小 f 值，移动方向由点 (wi, fi) 处的梯度表示：如果梯度 (wi) 是负的，则向增加 w 的方向移动；否则，向减少 w 的方向移动。经过一定的移动后，如果我们能在点 (w f) 处找到最小 f，我们称模型在权重 w 处收敛，并且我们已经找到了参数 *w。否则，模型是非收敛的。在我们找到收敛的 w 后，找到参数 b 相对容易，我们找到了最佳拟合线：f(x) = wx + b**，它可以用来预测新值 x 的房价。

扩展到多个特征（变量）

通过梯度下降算法，我们能够找到最适合样本数据集的最佳模型。我们将用它来预测新数据中的销售价格（目标 y）。在现实生活中，有许多特征会影响房屋的销售价格，例如其年龄、卧室和浴室的数量，当然还有房屋的位置。因此，我们需要将我们的模型扩展到多个特征（变量）。

当扩展到多个特征时，我们使用向量 X=(x1, x2, x3, …, xn)T 来表示多个特征值 x1, x2, x3, …, xn，线性函数将变为如下：

Y=WX+B

其中 W 是一个矩阵，B 是一个向量。

然后，代价函数可以写成如下形式：

F(W)=WTAW/2 

其中 A 是从数据集中构建的矩阵。

从数学上讲，我们可以通过使用多个变量的偏导数找到使 F(W) 最小的 W 值。相应地，我们也可以将梯度下降算法从一维扩展到多维度，通过最小化代价函数 F(W) 来找到最佳拟合数据集的矩阵 W。

扩展到非线性回归

在之前的讨论中，我们假设销售价格（目标 y）和房屋面积 x 之间的关系是线性的。在许多现实生活中的机器学习模型中，总是存在非线性关系，例如，一个多项式关系（这里有一个特征/变量 x）：

y = w1x + w2x2 + w3x3 + …. + wnxn

从线性到非线性，数学逻辑是相同的——我们需要通过最小化代价函数来找到模型参数 (w1, w2,... wn)。

通过从线性单变量解决方案扩展到非线性和多变量，回归模型解决了预测连续值的机器学习问题类型。由于问题的数学复杂性，我们在此不再进一步讨论。在下一节中，我们将探讨另一种类型的机器学习问题，分类，并且我们将从二元分类的最简单情况开始。

二元分类

在上一章中，我们也讨论了另一个样本机器学习问题（示例 2）—— Zeellow Lender 正在尝试自动化对新贷款申请的批准或拒绝决策过程。由于模型输出是 是 或 否，这是一个二元分类问题。另一种分类问题是多类别分类。例如，给定一个图像，我们需要判断它是狗、猫还是牛。

对于分类问题，我们总是使用 概率 的概念。对于 示例 2，机器学习模型将根据客户的贷款违约概率输出 是 或 否：如果违约概率高于阈值，我们将拒绝申请。对于图像分类示例，我们将说明图像是猫、狗还是牛的可能性。让我们从 示例 2 的二元问题开始。

逻辑回归

从数学的角度来看，示例 2 是一个寻找目标 (是/否) 与应用特征之间函数（关系）的问题，而我们唯一拥有的就是样本数据集。那么，我们如何找出这个函数呢？让我们检查一下我们拥有的一个简单的与 示例 2 相关的数据集：在一定地点一定时间段内 10 个贷款申请的决定。样本数据集显示在 表 4.6 中。

表 4.6 – 示例 2 贷款数据集

从 表 4.6 中，我们可以看到有许多申请人的特征会影响他们的贷款申请的批准或拒绝。为了简化，我们选择申请人的收入 x 作为单一特征/变量，并使用 z 作为 x 的线性函数：

z = wx + b

由于最终输出目标是一个 是 (1) 或 否 (0)，我们需要一个将上述 z 值映射到介于 0 和 1 之间的概率 p 的函数：批准贷款（目标变量 y=1）的概率。

从统计学中，我们有以下内容：

p=ez/(1+ez)=1/(1+e-z)

这就是所谓的 sigmoid 函数 (图 4.7)，它将贷款批准的概率 p 与 z 的值映射。

图 4.7 – Sigmoid 函数

使用 Sigmoid 函数，输出将实值 z 转换为介于 0 和 1 之间的概率值 p。这引入了 逻辑回归 的概念，这是一种用于预测目标值为 是 (1) 的概率的分类算法。简单来说，逻辑回归可以被视为一个输出为目标概率为 1 的概率范围在 (0,1) 之间的线性回归。

二元分类的阈值

如我们从先前的二元分类模型中看到的那样，逻辑回归返回一个介于 0 和 1 之间的概率值。要将概率值转换为分类，我们需要确定阈值值——当概率高于阈值时，类别为 1（是）；否则，为 0（否）。对于 示例 2，如果你将阈值设置为 0.9，那么当概率高于 90% 时，你将批准贷款申请；否则，你将拒绝申请。但我们是如何定义阈值的呢？答案是相关的业务案例和一个称为 混淆矩阵 的模型度量指标。我们将在模型验证部分进一步讨论它们。

扩展到多类分类

我们可以将二元分类问题扩展到多类分类问题。从二元到多类的转换有多种方法。给定一个多分类模型，我们可以将其分解为多个二元分类问题。更多详情请参阅以下链接：

svivek.com/teaching/lectures/slides/multiclass/multiclass-full.pdf

到目前为止，我们已经讨论了回归和分类问题，并介绍了梯度下降算法。现在让我们看看一些高级算法。

支持向量机

一种流行的先进机器学习算法被称为支持向量机，或SVM。它是一个常用于分类问题的模型。SVM 的想法很简单：算法找到一个线（二维）或超平面（三维或更多维度），将数据分成不同的类别。

让我们用一个二维分离问题来说明 SVM。如图图 4.8所示，我们试图找到一条线，将点分成两组：一组圆和一组正方形。有三条线在分隔点。在这三条线中，哪一条是最好的选择？

图 4.8 – SVM 示意图

让我们更仔细地看看这张图。对于每条线，都有来自两个类别的最近点——我们称这些点为支持向量，我们称线与其支持向量之间的距离为间隔。SVM 的目标是最大化间隔。在图 4.8中的三条线中，你可以看到线 1 是我们的选择，因为它是三条线中间隔最大的。

图 4.9 – 分隔数据的非线性曲线

如果我们将这个二维问题扩展到三维，那么具有最大间隔的超平面是最佳超平面。然而，两者仍然是线性模型。然而，在现实生活中，分离往往是线性的。图 4.9显示了一个分离是圆（非线性）的例子。

决策树和随机森林

对于具有多个特征的分类机器学习问题，自然而然的想法是对特征值进行分类——在每个特征上进行二进制分类。另一种流行的机器学习算法，决策树模型，使用这种逻辑来构建决策树，其中每个内部节点代表对特征的测试，每个叶节点代表一个类标签，分支代表导致叶节点的特征组合——即类标签。从根到叶，路径代表分类规则。决策树是根据每个特征的不同条件来分割数据集的。

决策树是监督学习中应用最广泛的方法之一。图 4.10展示了之前讨论的示例 2中决策树的逻辑流程：贷款申请决策过程。决策树从信用历史开始：

• 如果信用历史（评分）良好，它将检查申请人的收入和贷款金额——如果收入低且贷款金额大，它将拒绝申请。否则，贷款申请将被批准。

• 如果信用历史不良，它将检查申请人的收入和贷款金额——如果收入高且贷款金额小，它将批准申请。否则，贷款申请将被拒绝：

图 4.10 – 示例 2 的决策树

使用决策树模型，你可以根据新的特征数据预测结果，例如新应用的特性值。然而，在数据集大小很大的情况下，决策树可能会变得复杂，并可能导致过拟合。为了解决这个问题，我们通常使用随机森林，它由许多决策树组成。随机森林从这些单个决策树中获得预测，并通过结合决策树预测值以及投票或平均过程进行最终优化。随机森林通常比单个决策树更好，因为它通过平均或投票机制避免了过拟合。

在本节中，我们讨论了各种机器学习模型训练算法：从单变量线性回归到多变量非线性回归；从二元分类到多类分类；从支持向量机到决策树和随机森林。机器学习训练的结果是一个很好地拟合训练数据集的模型。这样的模型在新生产数据上做出良好预测的可能性如何？答案是，在将模型部署到测试和预测生产数据之前，我们需要使用验证数据集来验证模型。

验证模型

在你训练模型之后，你需要确定模型在预测未来新数据的目标时是否会表现良好，这就是验证过程：你必须在一个未用于训练的标记数据集上验证模型性能，这个验证数据集是在数据集分割阶段构建的。

模型验证

回想我们在第三章中讨论的内容：在机器学习问题定义阶段，你定义业务问题并制定一个业务指标来衡量模型的成功。现在，在这个模型验证阶段，模型验证指标需要尽可能紧密地与那个业务指标相联系。

在本章早期，我们已经定义了成本函数，该函数用于找到最优模型。成本函数也用于机器学习模型验证。对于回归问题，成本函数（模型值与实际值之间的差距）通常是均方误差（MSE），这在上一节中已经讨论过。对于二元分类，成本函数通常用混淆矩阵来表示。让我们更详细地看看混淆矩阵，以及改变分类阈值对混淆矩阵的影响。

混淆矩阵

混淆矩阵用于衡量二元分类模型的预测，如图 4.11 所示。

图 4.11 – 混淆矩阵

根据模型是否预测了实际类别，有四种情况：

• 真正例（TP）是指模型正确地预测了正类。

• 真负例（TN）是指模型正确地预测了负类。

• 假正例（FP）是指模型错误地预测了正类。

• 假负例（FN）是指模型错误地预测了负类。

让我们看看一个计算机视觉机器学习问题：你训练了两个模型进行图像识别 – 将图像分类为猫或非猫。你已经在这两个模型上运行了验证数据集，并将结果与标签进行了比较，图 4.12 显示了两个机器学习模型的混淆矩阵。我们如何衡量哪个模型表现更好？

图 4.12 – 两个机器学习模型的混淆矩阵

为了帮助我们比较分类模型的性能，我们需要定义更多的指标：

• 召回率（灵敏度）衡量的是实际正例中被正确识别的比例：

  Recall =TP/(TP+FN)
  

• 特异性衡量的是实际负例中被正确识别的比例：

  Specificity =TN/(FP+TN)
  

将上述指标应用于两个模型，我们得到了以下表格：

表 4.13 – 两个机器学习模型的召回率和特异性

根据业务目标，可以从不同的角度衡量和解释这两个模型的性能。如果目标是尽可能多地识别猫，并且假正例的数量并不重要，那么第二个模型表现更好，因为它有较高的召回率指标。然而，如果你的目标是识别非猫，那么第一个模型可能是一个更好的选择，因为它有较高的特异性指标。

你可以使用更多的指标来帮助你做出决策。接下来，我们将介绍接收者操作特征曲线和曲线下面积的概念。

ROC 曲线和 AUC

在前面的章节中，我们讨论了将概率转换为类别的截止值。阈值将影响混淆矩阵。

接收者操作特征（ROC）曲线是一个图表，显示了在所有阈值值下，真正例率（TPR）和假正例率（FPR），作为两个维度。

真正例率（TPR）是召回率的同义词，因此定义为如下：

TPR =TP/(TP+FN) (Of all the positive cases, the proportion of cases identified as positive)

假正例率（FPR）的定义如下：

FPR =FP/(FP+TN) (Of all the native cases, the proportion of cases identified as positive)

图 4.14 – ROC 曲线

要构建 ROC 曲线，您需要计算每个阈值下的 TPR（或召回率）与 FPR 的对应值，并在图上绘制。图 4.14展示了样本 ROC。如果我们仔细观察图表，我们会看到(0,0)点代表零真正例和零假正例。(1,1)点意味着所有正例都被正确识别，但所有负例也被错误地识别。从(0,0)到(1,1)的虚线，称为随机分类器，代表TPR=FPR。在图中，理想线是完美分类器，代表TPR=1且没有假正例：

图 4.15 – AUC：曲线下的面积

对于分类问题，目标是模型具有高 TPR（真正例率）和低 FPR（假正例率）——尽可能接近完美分类器——因此我们经常使用曲线下面积（AUC）-ROC 作为分类模型性能的衡量标准：AUC-ROC 越大，越好。图 4.15展示了样本 AUC-ROC。

更多分类指标

如您所见，从混淆矩阵的四个数字中，您可以计算出模型的召回率和特异性，在此我们介绍准确率、精确率和 F1-score：

• Accuracy 衡量在所有案例中正确预测的比例：

  Accuracy=(TP+TN)/(TP+TN+FP+FN)
  

• Precision 衡量实际正确的正识别比例：

  Precision=TP/(TP+FP)
  

• F1-score 结合了精确度和灵敏度，衡量整体性能：

  F1-score =2 X Precision X Recall/(Precision + Recall)
  

到目前为止，我们已经介绍了许多分类指标——你应该选择哪一个？这实际上取决于业务背景和目标。对于一个将电子邮件识别为垃圾邮件或非垃圾邮件的分类模型，虽然精确度有助于识别垃圾邮件，但你也不想将合法电子邮件误标为垃圾邮件。对于一个识别患者是否患有绝症的分类模型，识别实际患有该疾病的患者至关重要。在这种情况下，灵敏度比精确度是一个更好的指标。

F1 分数结合精确度和召回率，给出一个量化整体性能的单一数字。当您有类别不平衡但希望保持精确度和灵敏度之间的相等性时，您可能想使用 F1 分数。

调整模型

在模型验证过程中，我们评估模型性能，有时会出现模型不适应当验数据集的情况。让我们检查不同的情况。

过拟合和欠拟合

欠拟合描述的是预测误差没有最小化的情况，而过拟合是指模型非常适应训练数据集但不适应当验数据集的情况。一个过拟合的模型在训练过程中会得到非常低的代价函数值，但在新数据上的预测表现很差。图 4.16描绘了欠拟合、稳健和过拟合的情况。

图 4.16 – 模型拟合

当我们试图最小化损失函数并避免欠拟合时，我们需要确保我们的模型是泛化的，而不是容易过拟合。从我们的机器学习实践中，我们知道过拟合通常是由于使模型比必要的更复杂而引起的。正如你在图 4.16中看到的那样，过拟合使训练模型记住数据。机器学习的根本原则是在不失去泛化的情况下使模型很好地拟合数据。为了避免过拟合，我们引入正则化来降低模型复杂性。

正则化

为了避免过拟合，我们需要降低模型复杂性。模型复杂性可以从两个方面来考虑：

• 模型复杂性作为具有非零权重的特征总数的函数

• 模型复杂性作为模型中所有特征权重的函数

正则化的想法是为了添加一个因子来惩罚模型复杂性并增强模型泛化。对应于前面的两种复杂性，我们有两种正则化/泛化类型：

• 使用L2 正则化公式量化复杂性，该公式将正则化项定义为所有特征权重平方的和——接近零的权重对模型复杂性的影响很小，而异常值权重可以产生巨大影响。岭回归使用 L2 正则化：通过添加一个相当于权重平方的惩罚来改变损失函数。设p为特征的数量，第i个特征的系数（权重）为wi；则，损失函数可以表示如下：

• 使用L1 正则化公式量化复杂性，该公式将正则化项定义为所有特征权重的绝对值之和——接近零的权重对模型复杂性的影响很大，而异常值权重的影响较小。Lasso 回归使用 L1 正则化：通过添加一个相当于权重绝对值的惩罚来改变损失函数：

你应该如何选择前面公式的参数 lambda？如果 lambda 值过高，模型将变得简单，存在欠拟合数据的危险。如果 lambda 值过低，模型将更加复杂，存在过拟合数据和导致新数据泛化问题的风险。lambda 的理想值产生一个既适合训练数据又对新数据泛化良好的模型。模型调整的一个目标是在模型复杂性和泛化之间取得平衡。

除了正则化之外，我们还可以使用提前停止来避免过拟合。提前停止是一种正则化形式，用于在训练使用迭代方法（如梯度下降）的学习者时避免过拟合。这意味着在训练结果足够好时结束训练，在模型完全收敛之前。

超参数调整

超参数调整是通过在数据集上运行多个训练作业来寻找模型最佳版本的过程。它使用你指定的算法和超参数范围，然后选择那些能产生最佳性能的模型超参数值，这些性能是通过你选择的指标来衡量的。

超参数有两种基本类型。第一种是模型超参数。它们直接与所选模型相关联，因此对模型性能有直接影响。它们有助于定义模型本身，例如，神经网络模型中的层数和所使用的激活函数。

第二种是算法超参数。它们不会直接影响到算法的性能，但会影响模型训练的效率和速度。例如，梯度下降算法的学习率可能会影响机器学习模型收敛的速度。

调整超参数的过程涉及改变超参数的值，并尝试找到那些能产生最佳结果值的超参数。常见的常调超参数包括以下内容：

• 批量大小：在模型更新之前，训练过程中处理的样本数量

• 训练轮数：在模型训练过程中，我们遍历完整训练数据集的次数

• 学习率：在尝试找到参数最优值时我们所走过的距离

通过机器学习模型的训练、验证和超参数调整，我们已开发出一个可以用于测试的模型。

测试和部署模型

为了测试并从你的模型中获得性能指标，你必须从模型中进行推理或预测——这通常需要部署。部署阶段的目标是提供一个受管理的环境，以安全且低延迟的方式托管模型进行推理。你可以通过以下两种方式之一部署你的模型：

• 单次预测：通过一个永久端点在线部署你的模型。例如，我们可以通过在线端点部署房价预测模型。

• .csv 文件或一次发送多组记录，模型将返回一批预测结果。

在将模型部署到测试环境中后，你需要评估模型是否满足性能要求和业务需求，这是任何机器学习问题的最终目标。所有利益相关者都需要评估机器学习解决方案的益处，并批准模型在生产环境中的部署。请记住，最精确的模型可能并不是解决机器学习问题的最佳方案。

在所有利益相关者批准模型后，我们随后将模型部署到生产环境。否则，我们需要回到模型训练、验证和调整、重新测试和重新评估的过程。

在将模型部署到生产环境中后，您仍然需要监控生产数据，因为随着时间的推移，新的数据会不断积累，并且可能识别出替代或新的结果。因此，部署模型是一个持续的过程，而不仅仅是一次性练习。

使用 scikit-learn 进行模型开发实践

Scikit-learn 是 Python 中最有用的机器学习库之一。Scikit-learn 库包含许多机器学习工具，包括分类和回归工具。

在本书的 附录 3 中，我们提供了一系列使用 scikit-learn 开发机器学习模型的逐步实践练习。掌握这些步骤对于精通 scikit-learn 技能至关重要。请参阅 附录 3，使用 Scikit-Learn 进行实践，通过机器学习模型训练、验证和测试的示例来学习和实践。

摘要

在本章中，我们讨论了机器学习模型开发过程的基本概念：数据拆分、平台设置、机器学习模型训练、验证、测试和部署。

由于人工智能的概念在 1950 年代出现，直到 2012 年深度学习（DL）通过神经网络被发明，在此之前没有出现重大突破。深度学习极大地提高了机器学习模型的表现，并为将机器学习应用于许多商业用例开辟了广阔的道路。在下一章中，我们将讨论神经网络和深度学习。

进一步阅读

要深入了解本章的主题，您可以参考以下内容：

• scikit-learn.org/stable/tutorial/basic/tutorial.xhtml

• scikit-learn.org/stable/tutorial/index.xhtml

• 附录 3**, 使用 ScikitLearn 进行实践

第五章：理解神经网络和深度学习

自 2012 年首次亮相以来，深度学习（DL）取得了巨大的突破，并在包括计算机视觉、自然语言处理（NLP）在内的许多研究和工业领域得到应用。在本章中，我们将介绍以下基本概念：

• 神经网络和深度学习

• 成本函数

• 优化算法

• 激活函数

在掌握概念之后，我们将讨论几个神经网络模型及其商业用例，包括以下内容：

• 卷积神经网络（CNNs）

• 循环神经网络（RNNs）

• 长短期记忆（LSTM）网络

• 生成对抗网络（GANs）

在我们的云机器学习之旅中，理解神经网络和深度学习概念、常见模型和商业用例至关重要。让我们开始吧。

神经网络和深度学习

在我们人类的历史中，有许多有趣的里程碑，从视觉发展和语言发展到制造和使用工具。人类是如何进化的，我们如何训练计算机来看、说和使用工具？寻找这些问题的答案引领我们进入了现代人工智能领域。

我们的大脑是如何工作的？现代科学揭示，在大脑中，存在一个由神经元组成的分层神经网络。一个典型的神经元通过称为树突的精细结构从其他神经元收集电信号，并通过称为轴突的传导结构发送信号的尖峰，该轴突分裂成许多分支。每个分支的末端，一个突触将轴突的信号转换为电效应，以激发目标神经元的活性。图 5.1展示了生物神经元的运作机制：

图 5.1 – 生物神经元的工作原理

受生物神经网络模型的启发，人工神经网络（ANN）模型由称为感知器的人工神经元组成。感知器接收来自其他感知器的加权输入，应用传递函数，即加权输入的总和，以及激活函数，它向总和添加非线性激活，并将输出以激发下一个感知器。图 5.2展示了人工神经元（感知器）的运作机制：

图 5.2 – 人工神经元（感知器）的工作原理

ANNs 由通过层协同工作的感知器组成。图 5.3展示了多层 ANN 的结构，其中每个圆形节点代表一个感知器，一条线代表一个感知器的输出到另一个感知器的输入的连接。神经网络中有三种类型的层：输入层、一个或多个隐藏层和输出层。图 5.3中的神经网络有一个输入层、两个隐藏层和一个输出层：

图 5.3 – 多层人工神经网络

使用神经网络进行机器学习模型训练时，数据在网络中的流动如下：

1. 准备一个数据集 (x1, x2, x3, ..., xn*) 并将其发送到输入层，该层的感知器数量与数据集的特征数量相同。

2. 然后，数据移动到隐藏层。在每个隐藏层中，感知器处理加权输入（求和并激活，如前所述），并将输出发送到下一隐藏层的神经元。

3. 在隐藏层之后，数据最终移动到输出层，该层提供输出。

神经网络的目标是确定最小化成本函数（数据集的平均预测误差）的权重。类似于我们在前几章中讨论的回归模型训练过程，深度学习模型训练通过迭代两个部分的过程实现，即正向传播和反向传播，如下所示：

• 正向传播是信息从输入层流向输出层，通过隐藏层的路径。在训练过程的开始，数据到达输入层，在那里它们与随机初始化的权重相乘，然后传递到第一隐藏层。由于输入层有多个节点，每个节点都与第一隐藏层中的每个节点相连；隐藏层中的节点将加权值求和并应用激活函数（添加非线性）。然后它将输出发送到下一层的节点，那里的节点执行相同的操作，直到最后一个隐藏层的输出乘以权重并成为最终输出层的输入，在该层进一步应用函数以生成输出。

• 反向传播是信息从输出层流回输入层的路径。在这个过程中，神经网络将预测输出与实际输出进行比较，作为反向传播的第一步，并计算成本函数或预测误差。如果成本函数不够好，它就会根据如梯度下降（GD）等算法回退以调整权重，然后使用新的权重再次开始正向传播。

正向传播和反向传播会重复多次——每次网络调整权重，试图获得更好的成本函数值——直到网络在输出层获得良好的成本函数（可接受的准确度）。此时，模型训练完成，我们得到了优化的权重，这是训练的结果。

深度学习（DL）是使用神经网络训练机器学习模型。如果你将使用神经网络的前一 DL 模型训练过程与我们讨论的第四章中的训练模型部分，即[开发和部署机器学习模型]的过程进行比较，你会发现机器学习和深度学习的概念非常相似。通过迭代的前向传播和反向传播，两者都试图最小化模型的代价函数——机器学习更多地涉及计算机使用传统算法从数据中学习，而深度学习更多地涉及计算机模仿人脑和神经网络从数据中学习。相对而言，机器学习需要的计算能力较少，深度学习需要较少的人工干预。在接下来的章节中，我们将仔细研究深度学习中的代价函数、优化器算法和激活函数。

代价函数

我们在第四章的线性回归部分介绍了代价函数的概念。代价函数为我们提供了一种数学方法来确定当前模型有多少误差——它为错误的预测分配代价，并提供了一种衡量模型性能的方法。代价函数是机器学习模型训练中的一个关键指标——选择正确的代价函数可以显著提高模型性能。

常见的回归模型代价函数是 MAE 和 MSE。正如我们在前几章所讨论的，MAE 定义了预测值和标签值之间绝对差异的总和。MSE 定义了预测值和标签值之间差异平方的总和。

分类模型的代价函数相当不同。从概念上讲，分类模型的代价函数是不同类别的概率分布之间的差异。对于模型输出为二进制（1 代表是，0 代表否）的二分类模型，我们使用二元交叉熵。对于多分类模型，根据数据集标签的不同，我们使用分类交叉熵和稀疏分类交叉熵，如下所示：

• 如果标签是整数，例如，为了对狗、猫或牛的图片进行分类，那么我们使用稀疏分类交叉熵，因为输出是唯一的一个类别。

• 否则，如果标签被编码为每个类的一系列零和一（与我们在前几章讨论的 one-hot 编码格式相同），我们将使用分类交叉熵。例如，给定一张图片，你需要检测是否存在驾驶证、护照或社会保障卡，我们将使用分类交叉熵作为代价函数，因为输出是类别的组合。

成本函数是我们衡量模型的方式，以便我们可以调整模型参数以最小化它们——模型优化过程。在下一节中，我们将讨论最小化成本函数的优化器算法。

优化器算法

在第四章的线性回归部分，我们讨论了梯度下降法（GD）算法，该算法优化线性回归成本函数。在神经网络中，优化器是用于在模型训练中最小化成本函数的算法。常用的优化器包括随机梯度下降法（SGD）、RMSprop和Adam，如下所示：

• 随机梯度下降法（SGD）适用于非常大的数据集。与遍历训练数据集中所有样本以更新参数的梯度下降法（GD）不同，SGD 使用一个或多个训练样本的子集。

• RMSprop通过引入可变学习率来改进 SGD。正如我们在第四章中讨论的那样，学习率会影响模型性能——较大的学习率可以减少训练时间，但可能导致模型振荡并错过最佳模型参数值。较低的学习率可以使训练过程更长。在 SGD 中，学习率是固定的。RMSprop 随着训练的进行调整学习率，因此它允许你在模型具有高成本函数时以较大的学习率开始，但当成本函数降低时，它会逐渐降低学习率。

• Adam代表自适应矩估计，是最广泛使用的优化器之一。Adam 在 RMSprop 的自适应学习率中添加了动量，因此它允许在训练过程中向同一方向移动时加速模型的变化，使模型训练过程更快、更好。

选择合适的成本函数和优化算法对于模型性能和训练速度非常重要。Google 的 TensorFlow 框架提供了许多优化算法。有关更多详细信息，请参阅www.tensorflow.org/api_docs/python/tf/keras/optimizers。

神经网络的其他重要特性是非线性和输出归一化，这些特性由激活函数提供。我们将在下一节中检查它们。

激活函数

如前所述，激活函数是训练过程的一部分。激活函数的目的是将加权求和输入转换为节点：非线性化和改变输出范围。神经网络中有许多激活函数。我们将讨论一些最常用的：Sigmoid 函数、tanh 激活函数、ReLU 函数和 LeakyReLU 函数。图 5.4显示了这些函数的曲线：

图 5.4 – 激活函数

让我们按照以下方式检查前面的每个激活函数：

• sigmoid 激活函数在之前的“成本函数”部分已经讨论过。我们使用 sigmoid 函数将连续值转换为 0 到 1 之间的范围，这样模型就可以预测概率作为输出。

• tanh 激活函数与 sigmoid 非常相似，但输出范围是从 -1 到 +1，因此由于输出是零中心化的，它比 sigmoid 更受欢迎。

• ReLU 激活函数代表线性整流单元。它被广泛使用，因为它将负值转换为 0 并保持正值不变。其范围在 0 到无穷大之间。由于负区域的梯度值为 0，因此在训练过程中，某些神经元的权重和偏差可能不会更新，导致这些神经元永远不会被激活。

• LeakyReLU 是 ReLU 函数的改进版本，它通过在负区域具有一个小正斜率来解决“死亡 ReLU”问题。LeakyReLU 的优点与 ReLU 相同，除此之外，它还允许对负输入值进行训练。

另一个激活函数是 softmax 函数，它通常用于多类分类的输出层。softmax 激活函数将输出层值转换为概率之和为 1 的概率，从而在多类分类问题中为每个类别输出概率。

在所有这些激活函数中，我们应该选择哪一个？答案取决于诸如预测类型、网络架构、层数、网络中的当前层等因素。例如，sigmoid 函数更常用于二分类用例，而 softmax 函数通常用于多分类，回归问题可能或可能不使用激活函数。虽然一开始可能会有试错的过程，但经验会积累出良好的实践。

现在我们已经介绍了神经网络和激活函数的概念，让我们来看看在计算机视觉、自然语言处理（NLP）和其他领域常用的神经网络。

卷积神经网络

现在我们已经了解了神经网络和深度学习，让我们看看一些商业用例。

第一个案例是图像识别。我们如何教会计算机识别图像呢？这对人类来说很容易，但对计算机来说却非常困难。由于计算机只擅长处理 1 和 0，我们首先需要做的是将图像转换成一个数值矩阵，使用像素来实现。例如，图 5.5 展示了一个单位数 8 的黑白图像，它由一个 28x28 像素矩阵表示。人类可以通过眼睛中的某些神奇传感器轻松地将图像识别为数字 8，而计算机则需要输入所有 28x28=784 个像素，每个像素都有一个像素值——一个代表像素亮度的单个数字。像素值可能的范围从 0 到 255，其中 0 为黑色，255 为白色。介于两者之间的值构成了不同的灰度。如果我们有一个彩色图像，像素将具有三个数值 RGB 值（红色、绿色和蓝色）来表示其颜色，而不是一个黑色值。

图 5.5 – 使用像素值表示数字 8

在我们得到图像的像素矩阵表示后，我们可以开始开发用于训练的多层感知器（MLP）网络。我们将构建一个包含 784 个节点的输入层，并输入 784 个像素值，每个像素一个。输入层中的每个节点然后将输出到下一层（隐藏层）中的每个节点，依此类推。当层数增加时，整个网络的计算量将变得巨大。为了减少总计算量，特征过滤的概念应运而生，并导致了卷积神经网络（CNN）的概念。

CNNs 在计算机视觉中得到了广泛的应用，尤其是在图像识别和处理方面。一个 CNN 由三个层组成：卷积层、池化层和全连接层。卷积层对输入数据进行卷积，过滤图像特征，池化层压缩过滤后的特征，而全连接层，基本上是一个 MLP，负责模型训练。让我们详细考察这些层的每一个。

卷积层

卷积层执行卷积操作，该操作应用于输入数据以过滤信息并生成特征图。过滤器用作滑动窗口来扫描整个图像并自主识别图像中的特征。如图 5.6 所示，一个 3x3 的过滤器，也称为核（K），扫描整个图像（I）并生成一个特征图，用 IK* 表示，因为其元素来自 I 和 K 的乘积（例如图 5.6 中的例子：1x1+0x0+1x0+0x1+1x1+0x0+1x1+0x1+1x1=4）。

图 5.6 – 卷积操作

通过卷积过程提取图像特征并生成一个仍然包含大量数据的特征图，这使得训练神经网络变得困难。为了压缩数据，我们通过池化层进行处理。

池化层

池化层接收卷积层的输出，即特征图，并使用过滤器对其进行压缩。根据所使用的计算函数，它可以是最大池化或平均池化。如图图 5.7所示，一个 2x2 的过滤器块扫描特征图并对其进行压缩。使用最大池化时，它从扫描窗口中取最大值，max(15,8,20,9) = 20，依此类推。使用平均池化时，它取平均值，average(15,8,20,9) = 13。正如你所见，池化层的过滤器始终小于特征图。

图 5.7 – 池化层

从输入图像开始，卷积和池化过程迭代进行，最终结果输入到全连接层（MLP）进行处理。

全连接层

在卷积和池化层之后，我们需要将结果展平并传递给 MLP，一个全连接神经网络，以进行分类。最终结果将通过 softmax 激活函数激活，得到最终输出——对图像的理解。

循环神经网络

第二种神经网络类型是循环神经网络（RNN）。RNN 在时间序列分析，如 NLP 中得到了广泛应用。RNN 的概念在 20 世纪 80 年代出现，但直到最近，它在深度学习（DL）中才获得了动力。

如我们所见，在传统的前馈神经网络，如 CNN 中，神经网络中的一个节点只计算当前输入，并不记忆先前输入。因此，它无法处理需要先前输入的时间序列数据。例如，为了预测句子中的下一个单词，需要先前的单词来进行推理。通过引入一个隐藏状态，该状态记忆序列的一些信息，RNN 解决了这个问题。

与前馈网络不同，RNN 是一种神经网络，其中前一步的输出作为当前步骤的输入；使用循环结构保持信息，使神经网络能够接受输入序列。如图图 5.8所示，节点A的循环展开以解释其过程；首先，节点A从输入序列中取X0，然后输出h0，它与X1 一起是下一步的输入。同样，h1 和X2 是下一步的输入，依此类推。使用循环，网络在训练过程中持续记忆上下文：

图 5.8 – RNN 展开循环（来源：https://colah.github.io/posts/2015-08-Understanding-LSTMs/）

简单 RNN 模型的缺点是梯度消失问题，这是由于在训练过程中以及反向传播时使用相同的权重来计算每个时间步的节点输出。当我们向后移动时，误差信号变得更大或更小，这导致难以记住序列中更远的上下文。为了克服这一缺点，开发了LSTM神经网络。

长短期记忆网络

LSTM 网络被设计用来克服梯度消失问题。LSTMs 具有反馈连接，LSTMs 的关键是细胞状态——一条贯穿整个链的横向线，只有微小的线性交互，它持续保持上下文信息。LSTM 通过门控机制向细胞状态添加或移除信息，门控机制由激活函数（如 sigmoid 或 tanh）和点积乘法操作组成。

图 5.9 – LSTM 模型（来源：https://colah.github.io/posts/2015-08-Understanding-LSTMs/）

图 5.9 展示了一个具有保护和控制细胞状态的 LSTM。使用细胞状态，LSTM 解决了梯度消失的问题，因此特别擅长处理时间序列数据，如文本和语音推理。

生成对抗网络

GANs 是一种算法架构，用于生成可以以真实数据为假的新合成数据实例。如图 5.10 所示，GAN 是一种生成模型，它同时训练以下两个模型：

• 一个生成性（G）模型，它捕捉数据分布以生成可信数据。潜在空间输入和随机噪声可以被采样并输入到生成器网络中，以生成样本，这些样本成为判别器的负训练示例。

• 一个判别性（D）模型，它将生成的图像与真实图像进行比较，并试图识别给定的图像是伪造的还是真实的。它估计样本来自训练数据而不是真实数据的概率，以区分生成器的伪造数据和真实数据。判别器对生成器产生不可信结果进行惩罚。

图 5.10 – GAN（来源：https://developers.google.com/machine-learning/recommendation）

模型训练从生成器生成伪造数据开始，判别器通过比较与真实样本来学习识别它是虚假的。然后 GAN 将结果发送给生成器和判别器以更新模型。这种微调训练过程迭代进行，最终产生一些极其逼真的数据。GAN 可以用于生成文本、图像和视频，以及彩色或去噪图像。

摘要

神经网络和深度学习为传统的机器学习光谱增添了现代色彩。在本章中，我们首先通过检查成本函数、优化器算法和激活函数来学习神经网络和深度学习的概念。然后，我们介绍了高级神经网络，包括 CNN、RNN、LSTM 和 GAN。正如我们所见，通过引入神经网络，深度学习扩展了机器学习概念，并在计算机视觉、NLP 和其他许多应用中取得了突破。

本章结束了本书的第二部分：机器学习和深度学习。在第三部分，我们将专注于Google 方式学习机器学习，我们将讨论 Google 如何在 Google Cloud 上实现机器学习和深度学习。我们将从下一章学习 BQML、Google TensorFlow 和 Keras 开始。

进一步阅读

若想深入了解本章学习的内容，您可以参考以下链接：

• developers.google.com/machine-learning/crash-course/introduction-to-neural-networks/anatomy

• www.ibm.com/cloud/blog/ai-vs-machine-learning-vs-deep-learning-vs-neural-networks

• aws.amazon.com/what-is/neural-network/

• developers.google.com/machine-learning/gan

第三部分：在 GCP 中精通机器学习

在本部分，我们学习如何在 Google Cloud Platform 上实现机器学习。首先，我们了解 Google 的 BigQuery ML 用于结构化数据，然后我们查看 Google 的机器学习框架，TensorFlow 和 Keras。我们检查 Google 的端到端机器学习套件，Vertex AI，以及它提供的机器学习服务。然后，我们查看用于机器学习开发的 Google 预训练模型 API：GCP ML API。本部分最后总结了 Google Cloud 中机器学习实现的最佳实践。

本部分包括以下章节：

• 第六章, 学习 BQML、TensorFlow 和 Keras

• 第七章, 探索 Google Cloud Vertex AI

• 第八章, 发现 Google Cloud ML API

• 第九章, 使用 Google Cloud ML 最佳实践

第六章：学习 BQ/BQML、TensorFlow 和 Keras

在第一部分中构建了 GCP 和 Python 基础，并在第二部分中理解了机器学习概念和开发过程之后，我们现在进入本书的第三部分：在 GCP 中精通机器学习。我们将从学习 Google 如何对结构化数据进行机器学习以及 Google 机器学习框架 TensorFlow 和 Keras 开始。在本章中，我们将涵盖以下主题：

• GCP BQ

• GCP BQML

• TensorFlow 简介

• Keras 简介

近年来，关系数据库在许多企业中得到广泛应用，因此结构化数据是许多企业可用的大数据的重要组成部分。Google 的 BQ 和 BQML 在关系/结构化数据处理和分析中发挥着重要作用。

GCP BQ

如我们在 第一章 的 Google Cloud BigQuery 部分中提到的，理解 Google Cloud 服务，BigQuery 是一个千兆字节云企业数据仓库。BigQuery 具有以下特点：

• 完全托管 GCP 服务 – 您无需关心底层后端数据处理基础设施，包括计算、网络存储和其他资源。

• 无服务器 – 在 BigQuery 中，您无需管理任何服务器。所有数据处理引擎都由 Google 负责，包括不可见的 BigQuery BI Engine 和 ML Engine。

• 高度可扩展 – 它具有极高的弹性，可以快速无缝地扩展到任何规模。

• 经济高效 – 您只需为使用的 BigQuery 资源付费。

在 Google Cloud 大数据处理管道中，BigQuery 是数据摄取、存储、分析和可视化的关键服务，如下所示：

• BigQuery 以三种方式从数据源摄取数据：存档、批量处理和实时流。使用存档数据，您可以从计算机、GCS、其他 GCP 数据库（如 Bigtable）和 Amazon 简单存储服务（S3）等数据源创建包含表的数据集。使用批量处理，您可以从云存储或本地存储将数据加载到 BigQuery 中，源数据可以是 Avro、CSV、ORC、JSON、Parquet 或存储在 GCS 中的 Firestore 导出格式。实时事件可以流式传输到 BigQuery。一种常见的模式是将事件推送到 GCP Pub/Sub，使用数据流作业进行处理，然后将输出摄取到 BigQuery 中。

• BigQuery 使用可扩展的存储来存储数据，该存储符合 ACID 标准，且经济高效。BigQuery 中的存储和计算分离提供了高性能和服务解耦。

• BigQuery 使用内存中的商业智能引擎 – BigQuery BI Engine 处理数据。因为 BigQuery 支持符合 ANSI SQL 2011 标准的标准化 SQL，这为传统的关系数据库和专业人员转向 BQ 和 BQML 平台开辟了道路。使用 SQL，BigQuery 允许您快速运行查询、创建报告和仪表板，并将结果导出到 Google Sheets 或 GCS。

• 使用 BigQuery，您可以使用其集成的 Google Data Studio 工具可视化您的数据。利用 Data Studio 中的 BigQuery 连接器，您可以创建数据源、报告和图表，以可视化 BigQuery 数据仓库中的数据。您还可以利用其他工具，如 Google Datalab、Looker 和 Tableau。

您可以从 GCP 网页控制台启动 BigQuery 服务，或从 Cloud Shell 中的命令行工具启动 – bq是一个基于 Python 的命令行工具。还有许多客户端库，用于使用 C#、Go、Java、Node.js、PHP、Python、Ruby 等编程访问 BigQuery。

GCP BQML

BQML 允许数据科学家直接在 BigQuery 中使用标准 SQL 查询创建和训练机器学习模型。BQML 通过消除移动数据的需求，并直接使用 BigQuery 数据集作为训练和测试数据集，提高了机器学习模型开发的速度。BQML 训练的模型可以直接导出到 Vertex AI（将在后续章节中讨论）或其他云服务层。

BQML 可以通过以下方式访问和使用：

• 通过网页浏览器的 GCP 控制台

• 通过 Google Cloud Shell 或虚拟机 shell 的bq命令行工具

• BigQuery REST API

• 外部工具，如 Jupyter Notebook

如我们在第三章“准备机器学习开发”和第四章“机器学习模型开发和部署”中讨论的，机器学习过程包括数据准备、模型创建和训练、模型验证/评估以及模型部署/预测。让我们用 BQML 来回顾这个过程。

第一步是数据准备。使用 BQML，您可以通过在 BigQuery 控制台中加载 CSV 文件并在数据导入 BigQuery 后直接运行 SQL 语句来准备训练数据集。

第二步是模型创建和训练。BigQuery ML 支持以下机器学习模型：

• 线性回归 – 在这种情况下，我们有一些数据点，我们基本上通过拟合一条线到这些数据点来最小化误差。

• 二元逻辑回归 – 在这种情况下，我们有两个类别，并且我们将每个示例分配给其中一个类别。

• 多类逻辑回归 – 在这种情况下，我们有多于两个类别，并且我们将每个示例分配给其中一个类别。

• K-means 聚类 – 在这种情况下，我们有一些点，并且能够将它们分离成不同的簇。

• BQML 支持其他模型。有关更多详细信息，请参阅cloud.google.com/bigquery-ml/docs/introduction#supported_models_in。

BQML 通过使用 BQML 的create model语句在单步中实现模型创建和训练。使用我们在前几章中讨论的示例 2，表 6.1显示了贷款申请处理模型的两个样本，其中目标是二进制值，批准或不批准，特征包括申请日期、申请人信用评分、贷款金额、年收入、年龄等。

表 6.1 – 样本表结构

以下是用样本表t中的数据集创建具有逻辑回归模型的示例代码：

CREATE OR REPLACE MODEL m
 OPTIONS(MODEL_TYPE='LOGISTIC_REG' DEL_TYPE='LOGISTIC_REG')
AS 
SELECT * FROM t
WHERE t.date BETWEEN '20160801' AND '20190731'

当运行前面的代码时，BQML 将执行SELECT语句以过滤从 2016 年 8 月 1 日到 2019 年 7 月 31 日的所有样本，然后使用这些结果作为数据集输入来训练逻辑回归模型。

第三步是模型验证/评估，以确定模型的好坏。使用 BQML，模型评估是通过以下ML.EVALUATE函数完成的：

SELECT *
FROM
 ML.EVALUATE(MODEL `m`, (
SELECT * FROM t
WHERE t.date BETWEEN '20190801' AND '20200731'))

当运行前面的代码时，BQML 将执行SELECT语句以过滤从 2019 年 8 月 1 日到 2020 年 7 月 31 日的所有样本，然后使用这些结果作为数据集输入来评估分类器（逻辑回归模型）的性能。当代码完成时，您可以查看结果。

表 6.2 – 样本 BQML 模型评估结果

表 6.2显示了我们的二元分类模型的样本指标如下：

• Precision – 一个指标，用于识别模型在预测正类时正确的频率。

• recall – 一个指标，回答以下问题：在所有可能的正标签中，模型正确识别了多少个？

• accuracy – 分类模型预测正确的比例。

• f1_score – 精确率和召回率的调和平均值。

• log_loss – 逻辑回归中使用的损失函数。

• roc_auc – ROC 曲线下的面积。

根据业务用例，我们可以审查评估结果，衡量模型性能，并找到业务指示。在模型评估过程中，我们可以使用model create语句调整模型参数。更多详情请参阅cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-hyperparameter-tuning。

在第四步中，我们可以使用模型来预测生产结果。以下是一个预测结果的示例查询：

SELECT * 
FROM 
ML.PREDICT(MODEL `m`, (
SELECT * FROM t
WHERE t.date BETWEEN '20200801' AND '20210731'))

如您从前四步中可以看到，BQML 在 BigQuery 云服务中完成了机器学习开发的全部过程。对于结构化数据，BQML 为我们数据科学家训练和开发机器学习模型提供了许多优势。

Google Cloud BQ 和 BQML 提供结构化数据处理和学习服务，并且在许多商业用例中得到了广泛应用。在下一节中，我们将介绍 Google 的机器学习框架，TensorFlow 和 Keras。

TensorFlow 简介

TensorFlow 是由 Google Brain 开发的端到端开源机器学习平台，并且是数据科学家最广泛使用的机器学习框架之一。

TensorFlow 流张量 – TensorFlow 的名称直接来源于其核心框架组件：张量。让我们先从理解张量开始。

理解张量的概念

张量是一个容器，它在一个 N 维空间中以各种大小和形状存储数据。张量可以来自输入数据或输入数据的计算。在机器学习中，我们称张量的组件为特征。张量有三个主要特征来描述自身，称为张量的秩、形状和dtype，如下所示：

• 秩是方向的数量

• 形状是每个方向上的元素数量

• Dtype 是数据类型

张量的秩指定了测量张量的方向数量。从秩的数量，可以将张量分类如下：

• 秩 0：一个只有大小和 0 个方向的张量。

• 秩 1：一个具有一个方向和大小的张量。

• 秩 2：一个具有两个方向（行和列）的张量，每个元素都有一个大小。

• 秩 3：一个具有三个方向的张量。

• 秩 4：一个具有四个方向的张量。

• 高秩张量。

图 6.3 使用基本几何对象说明了张量的秩，如下所示：

• 秩为 0 的张量是一个具有大小但没有方向的单个标量。

• 秩为 1 的张量是一个具有一个方向和大小的向量。

• 秩为 2 的张量是一个具有两个方向（行和列）的矩阵，其元素具有大小。

• 秩为 3 的张量有三个方向——其元素具有二维大小。

• 秩为 4 的张量是秩为 3 传感器的列表。

图 6.3 – 张量的秩

如果我们使用在第二章的Python 基本数据结构部分中讨论的list数据类型来定义张量的秩，那么每个张量的秩都给我们一个来自前一个秩传感器的对象列表，如下所示：

• 秩为 1 的张量（向量）给我们一个秩为 0 的张量（标量）列表。

• 秩为 2 的张量（矩阵）给我们一个秩为 1 的张量（向量）列表。

• 秩为 3 的张量（张量）给我们一个秩为 2 的张量（矩阵）列表。

• 秩为 4 的张量给我们一个秩为 3 的张量列表（张量）。

让我们用一个彩色图像作为例子来说明张量的 rank 概念。对于一个彩色图像，我们可以使用三个通道来描述每个像素：一个红色通道、一个绿色通道和一个蓝色通道。每个通道测量像素在该颜色通道内的强度。红色通道是一个 rank 2 的张量，因为它使用矩阵来表示红色光下的图像像素映射（0 表示没有光，255 表示最大光），绿色通道和蓝色通道也是如此。结合这三个通道，我们得到一个 rank 3 的张量。如果我们为颜色帧/图像的顺序添加一个时间轴来形成视频，那么它就变成了 rank 4 的张量。如果我们然后对视频进行批处理，那么它将生成一个 rank 4 张量的列表——一个 rank 5 的张量。

在我们检查了张量的秩之后，让我们来看看张量的形状和 dtype（数据类型）——形状是张量元素的数量，dtype 是元素的类型。对于秩为 0、1、2、3 和 n 的张量，我们有以下内容：

• rank 0 张量（标量）的形状是空的 ()。

• 对于形状为 rank 1 的张量，例如向量 ([3, 5, 7])，其形状是 (3)，因为它有三个元素。

• 例如，对于形状为 rank 2 的张量，比如矩阵 ([3, 5, 7], [4, 6, 8])，其形状是 (2,3)，因为它在一个方向（行）上有两个元素，在另一个方向（列）上有三个元素。

现在我们对张量概念有了很好的理解，让我们来看看 TensorFlow 名称的第二部分，flow（流动），看看张量是如何流动的。

张量的流动

为了描述在 TensorFlow (TF) 框架中张量的流动，我们采用一个带有节点和边的计算图，称为 有向无环图 (DAG)。有向意味着张量（数据）沿着图中的路径以给定的顺序移动。无环意味着移动路径不形成任何循环。因此，张量在无环的 DAG 中流动以转换数据。

使用 DAG，张量有一个节点和一个边。节点代表我们对张量/数据执行的操作，边代表张量/数据流动的路径。让我们用一个 DAG 来描述一个示例算法。如图 图 6.4 所示，我们输入两个数字，将它们相乘得到它们的乘积，然后将数字相加得到它们的和。然后，我们将乘积除以和并打印结果。如果我们用变量替换常数并添加更复杂的数学运算，我们可以看到这个张量流动过程实际上是一个机器学习模型——我们可以改变变量或权重，从输入中产生预期的输出。

图 6.4 – 带有 DAG 的示例算法

由于 DAGs 是单向的并且有执行顺序，当张量在图中流动时，我们可以并行化操作。例如，如果你想要添加 1,000 个张量并乘以相同的 1,000 个张量，可以通过利用多个 CPU、图形处理单元（GPU）、张量处理单元（TPU）核心，甚至量子处理器（QU）将操作分配到多个计算资源来并行执行加法和乘法操作。由于 DAG 允许在不同物理机器或平台上执行并行操作，我们可以在分布式服务器农场或边缘设备上进一步并行执行这些操作。众所周知，云计算具有按需、全球分布、自动可扩展和按使用付费的特点，因此它为并行化 TensorFlow 操作和训练 ML 模型提供了一个完美的环境。正如我们在前面的章节中讨论的那样，Google Colab 预装了 TensorFlow 包，你可以在 Colab 中免费练习 TensorFlow。

现在我们已经掌握了张量的概念，并了解了张量如何在 TF 框架中流动，是时候介绍 Keras 了——这是一个为我们设计的高级 API，使我们能够非常容易地使用 TensorFlow 开发 ML 模型。

Keras 简介

Keras 是一个 Google 平台，是构建 ML/DL 模型的 TensorFlow 高级接口。Keras 提供了一个高级 API，它使用称为层的逻辑单元来封装数据转换和操作，作为创建神经网络的构建块。一个层执行数据操作，例如取平均值、计算最小值等。

使用 Keras，ML 模型是由层构建的。在 ML 模型训练过程中，通过反向传播调整层的变量，以优化模型成本函数。在幕后，TensorFlow 和 Keras 在后台完成详细的数据操作，例如线性代数和微积分计算。Keras 提供了以下两个 API：

• 顺序 API提供了最简单的接口和最低的复杂性。使用顺序 API，我们可以逐层创建模型，从而将 ML/DL 模型构建为一个简单的层列表。

• 功能 API比顺序 API 更灵活、更强大，因为它允许层的分支或共享。使用功能 API，我们可以为 ML 模型提供多个输入和输出。

以下代码片段展示了使用顺序 API 进行 ML 模型训练：

##Import the tensorflow libraries
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation
from tensorflow.keras.optimizers import Adam
## Creating the model
model = Sequential()
model.add(Dense(4,activation='relu')) 
model.add(Dense(4,activation='relu'))
model.add(Dense(1))
## defining the optimizer and loss function
model.compile(optimizer='adam',loss='mse')
## training the model
model.fit(x=X_train,y=y_train,
          validation_data=(X_test,y_test),
          batch_size=128,epochs=400)

以下代码片段展示了使用功能 API 进行 ML 模型训练：

##Import the tensorflow libraries
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input,Dense
## Creating the layers
input_layer = Input(shape=(3,))
Layer_1 = Dense(4, activation="relu")(input_layer)
Layer_2 = Dense(4, activation="relu")(Layer_1)
output_layer= Dense(1, activation="linear")(Layer_2)
##Defining the model by specifying the input and output layers
model = Model(inputs=input_layer, outputs=output_layer)
## defining the optimizer and loss function
model.compile(optimizer='adam',loss='mse')
## training the model
model.fit(X_train, y_train,epochs=400, batch_size=128,validation_data=(X_test,y_test))

如我们所见，前两个 Keras API 各有其优缺点。顺序 API 简单直接，而功能 API 可以用来构建复杂模型。

摘要

在本章中，我们讨论了 Google Cloud BQ 和 BQML，并介绍了一些使用 BQ/BQML 进行数据处理和 ML 模型开发的示例。我们还学习了 TensorFlow 和 Keras 的概念——这是 Google 用于构建 ML 模型和项目的框架。

在下一章中，我们将重点关注 Vertex AI，它为 Google Cloud 中的 ML 提供了一个端到端平台。

进一步阅读

关于本章学习的进一步见解，您可以参考以下链接：

• cloud.google.com/bigquery/docs/

• cloud.google.com/bigquery-ml/docs/

• www.tensorflow.org/

• keras.io/about/

第七章：探索 Google Cloud Vertex AI

在上一章中，我们讨论了 Google Cloud BQML，它用于从结构化数据中开发机器学习模型，以及 Google 的 TensorFlow 和 Keras 框架，它们为机器学习模型开发提供了一个高级 API 接口。在本章中，我们将讨论 Cloud Vertex AI，这是 Google 为机器学习模型开发提供的集成云服务套件。我们将检查 Vertex AI 套件及其所有产品和服务。

Google Vertex AI 是一套集成的 Google Cloud 产品、功能和管理界面，它简化了机器学习服务的管理。它为用户提供了一个完整的平台，从端到端构建、训练和部署 Google Cloud 中的机器学习应用程序。Vertex AI 为数据科学家提供了一个单一的平台来构建机器学习应用程序。

在本章中，我们将讨论以下 Vertex AI 产品和服务：

• Vertex AI 数据标记和数据集

• Vertex AI 特征存储

• Vertex AI 工作台和笔记本

• Vertex AI 训练

• Vertex AI 模型和预测

• Vertex AI 管道

• Vertex AI 元数据

• Vertex AI 实验 和 TensorBoard

让我们从 Vertex AI 套件中的数据标记和数据集开始。

Vertex AI 数据标记和数据集

数据集在机器学习过程中扮演着如此重要的角色，以至于数据集的质量对机器学习模型性能有着巨大的影响。正如我们在第四章，“开发和部署机器学习模型”中讨论的那样，数据准备是任何机器学习过程中的第一步和最重要的步骤。

Vertex AI 数据标记是 Google Cloud 服务，允许最终用户与人类工作者合作，审查和标记用户上传的数据集。数据集标记后，它们可用于训练机器学习模型。这些人类工作者由 Google 雇佣，用户需要向人类工作者提供数据集、标签和标记说明。

最终用户也可以直接上传标记过的数据集。Vertex AI 数据集是 Google Cloud 服务的一部分，它为用户提供上传不同类型数据的能力，用于构建、训练和验证机器学习模型。目前，Vertex AI 支持四种类型的数据集（图像、表格、文本和视频）：

• 图像数据集：您可以在 Vertex AI 中创建图像数据集，并使用它们来训练图像分类、图像分割和目标检测的模型。使用 Vertex AI，您可以直接上传图像数据集或使用存储在 Google Cloud Storage 存储桶中的图像。

• 表格数据集：您可以直接从您的本地计算机上传一个 CSV 文件，使用 Google Cloud Storage 中的一个，或者从 BigQuery 服务中选择一个表格。一旦生成了表格数据集，数据就可在 Vertex AI 数据集中用于模型训练。

• 视频数据集：Vertex AI 允许您直接从本地计算机上传视频或使用 Google Cloud 存储桶中的视频。一旦您拥有视频数据集，您可以使用它们进行视频分类或动作识别。

• 文本数据集：在 Vertex AI 中，您创建一个文本数据集，并将 Google Cloud 存储桶中的 CSV 文件导入到数据集中。然后，您可以使用该数据集进行文本文档分类、自定义文本实体识别、情感分析等。

Vertex AI 数据集允许您在 Vertex AI 套件中直接创建和管理数据集，并通过 Vertex AI 上传的数据集将自动存储在由 Vertex AI 创建和管理的云存储桶中。

Vertex AI Feature Store

在机器学习/深度学习模型训练中，特征是构建模型和进行未来推理的属性。Google Vertex AI Feature Store 是一个完全托管的云服务，提供集中式存储库来存储、组织和提供机器学习特征。您可以创建和管理一个包含所有模型特征及其值的 Vertex AI Feature Store。使用中央特征存储，Google Cloud 组织中的用户可以共享和重用这些特征，用于不同机器学习/深度学习项目中的模型训练或服务任务，以加快机器学习应用程序开发和模型部署。

Vertex AI Feature Store 允许用户管理机器学习模型中的特征。特征存储可以提供实时在线预测或为新数据提供批量预测。例如，在加载有关观影习惯的信息后，特征存储可以用来根据用户的特征预测新用户可能会观看的电影。

在传统的机器学习框架中，您可能已经计算了特征值并将它们保存在各种位置，包括云存储桶或 BQ 表，并且您可能有单独的解决方案来存储和管理特征值。使用 Vertex AI Feature Store，您将获得一个统一的解决方案，在整个组织中保持一致，用于存储和提供可以由不同团队在不同项目或用例中共享的特征。

Vertex AI Workbench 和笔记本

Vertex AI Workbench 服务提供了一个单一的开发平台，用于整个数据科学工作流程；您可以使用它来启动云 VM 实例/笔记本以查询和探索数据，并开发用于部署的模型。

如我们之前在“准备平台”部分中解释的那样，Jupyter Notebook 是一个广泛使用的机器学习模型开发平台。Vertex AI Workbench 为您的数据科学家提供两种基于 Jupyter-Notebook 的选项：托管笔记本和用户托管笔记本：

• 托管笔记本是 Google 管理的、基于 Jupyter 的、可扩展的、企业级计算实例，可以帮助您设置并在一个端到端的机器学习生产环境中工作。

• 用户管理的笔记本是高度可定制的实例，因此非常适合需要对其环境有大量控制权的用户。使用用户管理的笔记本实例，您将预装一系列深度学习包，包括 TensorFlow 和 PyTorch 框架。

Vertex AI Workbench 提供灵活的笔记本选项。它为数据科学家提供了一个优秀的机器学习模型训练平台，用于训练和开发模型。

Vertex AI 训练

在机器学习模型开发过程中，训练作业是生成机器学习模型的离散任务。在 Vertex AI 中，您可以根据模型和数据来源选择不同的训练方法；Vertex AI AutoML，由 Google 管理，使用 Google 的模型和您的数据进行训练，而Vertex AI 平台，使用用户定义的代码或自定义容器，利用您的模型和您的数据进行模型训练。

Vertex AI AutoML

Vertex AI AutoML 是一个托管的 Google Cloud 服务，它使用户能够在不编写任何代码的情况下构建各种用例的模型。目标是使不同水平的 AI 专业知识都能进行机器学习模型开发。

Vertex AutoML 支持的模型类型如图 7.1 表所示：

表 7.1 – Vertex AI AutoML 模型

在创建 AutoML 训练管道作业时，您有以下选项：

• 数据集：由 Vertex AI 管理，并由用户上传

• 模型类型：从支持的模型中选择（如上所述）

• 数据拆分（可选）：使用自定义参数在训练数据、验证数据和测试数据之间拆分数据集

• 加密（可选）：选择客户管理的加密密钥（CMEK）进行过程中的加密

Vertex AI AutoML 帮助您根据您的训练数据构建无代码模型。使用 Vertex AI AutoML，您可以使用自己的数据自定义 Google 的模型。

Vertex AI 平台

Vertex AI 平台，通过自定义容器，使您能够从零开始使用自己的数据构建自己的模型。自定义容器是用户创建的 Docker 镜像，在创建管道时选择。自定义容器环境的典型工作流程如图 7.2 所示，其步骤如下：

1. 代码开发：您可以选择您喜欢的编程语言来构建应用程序，无论是在本地还是在笔记本中，默认情况下可以从任何互联网位置获取依赖项。

2. 构建：您可以将代码构建到打包的工件中，或者编写配置来自动将代码和各种依赖项打包到容器运行时工件中。

3. 工件存储：您可以将新构建的定制工件推送到 Cloud Storage 或容器注册表。

4. 启动训练管道：在创建训练管道时，您可以选择自定义容器来构建机器学习模型。

图 7.1 – Vertex AI 平台自定义容器

在 Vertex AI 中训练模型后，你可以使用 AutoML 或自定义容器，这些容器在 Vertex AI 模型中访问/管理，并在 Vertex AI 端点中部署以进行单个预测或批量预测。

Vertex AI 模型和预测

Vertex AI 模型提供了一个管理 ML 模型的平台。使用 Vertex AI 模型，你可以以多种方式开发和管理工作流模型：

• 创建模型：用户可以选择创建一个新的模型，并重定向到训练管道屏幕。

• 上传模型：用户可以将训练好的模型上传到他们的 Vertex AI 项目中使用。

• 部署模型：用户可以将选定的模型部署到端点，使其通过 REST API 可用。

• 导出模型：用户可以将训练好的模型导出到 GCS 存储桶，在那里它可以被存储或用于其他项目。

在模型训练完成后，它们可以被公开或私下导出或部署以预测生产案例。当你将模型部署到端点资源以进行在线预测，或者当你请求批量预测时，你可以始终自定义预测服务使用的虚拟机类型，你也可以配置预测节点使用 GPU。我们将在下一节中讨论模型部署。

Vertex AI 端点预测

Vertex AI 端点允许用户基于 Vertex AI 模型创建 REST API 端点，以预测新数据的结果。使用 Vertex AI，模型可以被部署到公共端点或私有端点：

• 公共端点：模型被部署到互联网可路由的、Google 管理的端点，该端点位于所选区域。

• 私有端点：模型被部署到 Google 管理的端点，该端点位于所选区域的私有 IP 地址上所选 VPC。

Vertex AI 端点用于部署用于在线预测的训练模型。当创建新的端点时，用户可以配置以下内容：

• 端点名称

• GCP 区域

• 私有或公共访问

• 加密（可选）

• 模型（s）：新端点将要提供的一个或多个模型。

通过与 Vertex AI 训练和 Vertex AI 模型集成，Vertex AI 端点允许用户交互式地预测单个结果。

Vertex AI 批量预测

与 Vertex AI 端点不同，Vertex AI 批量预测作业是针对输入数据集运行预测模型的离散任务。如图 图 7.3 所示，它可以输入存储在 Google Cloud Storage 中的文件，并将结果输出到指定的 GCS 位置。

图 7.2 – Vertex AI 批量预测

当创建批量预测作业时，你有以下选项：

• 区域：模型存储的位置

• 模型：指向 ML 模型

• 输入数据：存储输入数据的云存储桶

• 输出目录：云存储桶用于存储预测结果

• 计算相关信息，包括机器类型和节点数量

如前所述的服务，Vertex AI 为您提供了一个 ML 开发和管理工作套件，用于创建和管理数据集，创建和管理用于模型训练的笔记本，以及开发和管理用于批量预测端点的模型。使用 Vertex AI，您可以执行 ML 工作流程中的所有任务，从端到端。这使我们转向 Vertex AI 管道的讨论：自动化 ML 工作流程。

Vertex AI 管道

Vertex AI 管道允许您使用TensorFlow Extended（TFX）或Kubeflow以无服务器的方式自动编排您的 ML 工作流程。每个 Vertex AI 管道作业都由一个配置文件生成，该文件概述了一系列步骤。典型的 Vertex AI 管道将数据导入数据集，使用训练管道训练模型，并将模型部署到新的端点进行预测。管道作业使用计算资源运行，有以下选项：

• 您可以使用Kubeflow DSL为管道作业编写自定义配置。

• 您可以创建、运行和安排管道作业。

• 您可以指定服务帐户或使用未指定时的计算默认服务帐户。

Google Vertex AI 管道根据您对工作流程作为管道的描述来编排您的 ML 工作流程。ML 管道是基于容器的可移植和可扩展的 ML 工作流程，由一系列输入参数和步骤列表组成——每个步骤都是管道的一个实例。

Vertex AI 元数据

Vertex AI 元数据是存储在 Vertex AI 各种组件中生成的元数据仓库。当在 ML 工作流程管道中开发模型时，会生成并存储元数据，您可以将这些元数据合并到单个元数据存储中，这使用户能够查询和回答以下问题：

• 哪个训练模型的版本达到了一定的质量阈值？

• 哪个管道运行/使用特定的数据集？

在 Vertex AI 管道中，用户还可以配置写入元数据存储的数据对象。然后，用户可以创建上下文对象，将这些数据对象组织成逻辑分组并获得更多见解。

使用 Vertex AI 元数据 API，用户可以构建模式、组织数据对象或查询存储在 Vertex AI 元数据中的数据。

Vertex AI 实验和 TensorBoard

TensorBoard是谷歌的一个开源项目，用于机器学习实验的可视化。Vertex AI 实验是 TensorBoard 的一个实现。使用 Vertex AI 实验，用户可以创建 TensorBoard 实例并将从 Vertex AI 模型生成的 TensorBoard 日志上传以运行实验——这些实验是各种指标（如损失函数和不同运行时间下不同模型参数的准确性）的视觉表示。"图 7.4"展示了 Vertex AI 实验和 TensorBoard 的示例工作流程：

图 7.3 – Vertex AI 实验和 TensorBoard

这些 TensorBoard 可视化可通过一个网络应用访问，通过设置 GCP IAM 权限与其他用户共享。通过 Vertex AI 实验，您可以配置以下选项：

• 管理 TensorBoard 实例：用户可以创建、更新或删除 TensorBoard 实例；实例用于实验。

• 创建实验：通过上传管道日志数据，用户可以生成实验和可视化。

• 查看 TensorBoard 网络应用：用户可以通过为每个 TensorBoard 实例生成的网络应用查看 TensorBoard。

• 导出数据：用户可以使用 API 导出管道元数据和 TensorBoard 数据点。

Vertex AI 实验为用户提供了一个平台来实验和调整模型参数。通过 Vertex AI 实验，我们可以在 TensorBoard 网页上交互并检查结果。它是 Google Vertex AI 套件的一个重要且不可或缺的部分。

摘要

在本章中，我们介绍了 Google Vertex AI 套件，包括其用于机器学习模型开发和部署的服务、平台和工具。使用 Vertex AI，您可以轻松灵活地管理数据集、模型和管道。毫无疑问，掌握 Vertex AI 需要对套件中的每个服务进行实际操作练习，我们已在附录 4，使用 Google Vertex AI 实践中提供了示例实际操作步骤。请遵循这些实践并理解附录中的步骤。在下一章中，我们将讨论另一个 Google Cloud ML 服务：Google Cloud ML API。

进一步阅读

为了深入了解本章的学习内容，您可以参考以下链接：

• Vertex AI 文档

cloud.google.com/vertex-ai/docs

• 所有数据集文档 | Vertex AI

cloud.google.com/vertex-ai/docs/datasets/datasets

• Vertex AI 特征存储简介

cloud.google.com/vertex-ai/docs/featurestore/overview

• Vertex AI 工作台简介

cloud.google.com/vertex-ai/docs/workbench/introduction

• 选择笔记本解决方案 | Vertex AI 工作台

cloud.google.com/vertex-ai/docs/workbench/notebook-solution

• Vertex AI 模型监控简介

cloud.google.com/vertex-ai/docs/model-monitoring/overview

• Vertex AI 管道简介

cloud.google.com/vertex-ai/docs/pipelines/introduction

• Vertex 可解释 AI | Vertex AI

cloud.google.com/vertex-ai/docs/explainable-ai

• 使用云控制台部署模型 | Vertex AI

cloud.google.com/vertex-ai/docs/predictions/deploy-model-console

• 附录 4, 使用 Google Vertex AI 进行实践

第八章：发现 Google Cloud ML API

应用程序编程接口（API）允许一个计算机程序使其数据和功能可供其他程序使用。换句话说，通过程序或服务的 API，用户可以向程序/服务发送请求并获取响应。ML API 是基于云的 AI 服务，通过利用云服务提供商（CSP）的 API，帮助您将机器智能构建到您的应用程序中。它们作为 REST API、客户端库 SDK 和用户界面提供。

Google Cloud ML API 提供了一种接口，用于在云中利用 Google 的机器学习服务。在本章中，我们将讨论 Google Cloud ML API 范围，包括以下云服务：

• Google Cloud sight API，包括 Cloud Vision API 和 Cloud Video API

• Google Cloud 语言 API，包括自然语言处理（NLP）和翻译

• Google Cloud 对话 API，包括语音转文本、文本转语音和 Dialogflow

让我们从 Google 的 Cloud Sight API 开始。

Google Cloud Sight API

Google Cloud Sight API提供了强大的 Google 预训练机器学习模型，用于视觉处理和视频处理。我们将探讨 Cloud Vision API 和 Cloud Video API 的概念。

Cloud Vision API

Cloud Vision API是一个通过 Google 预训练的高级机器学习模型来解码图像的工具。它可以解释图像并将它们分类到许多类别中。它可以提取和检测文本，无论文本是在图片中还是文档照片中。

Google Cloud Vision 允许开发者轻松地将视觉检测功能集成到应用程序中，包括图像标签、地标检测、标志检测和内容检测：

• 图像标签检测可以检测、识别和标记图像中存在的对象、位置、活动、动物种类、产品等许多其他事物。

• 地标检测可以在图像中识别地标，例如著名的地标和自然或人造结构。它提供地标的名称、边界多边形的顶点以及地标的地理位置（纬度和经度）。

• 标志检测可以在图像中检测流行的产品标志，例如流行的公司标志、产品标志等。

• 内容检测可以在图像中检测显性内容，例如成人内容、暴力内容、色情内容等。它提供了这样的内容存在于图像中的可能性。

以下是一些 Google Cloud Vision API 的应用案例：

• 文本数字化：Cloud Vision API 可以在图像中检测文本，尤其是在扫描图像中。最好的部分是您可以自定义自己的模型，并在核心内置功能之上为特定场景进行训练。例如，您可以将特定的医生处方放入自定义模型中，并在 Google 已提供的模型之上进行训练，使其更加健壮。

• 安全和监控：Google Cloud Vision 提供了非常精确的面部识别、面部比较和面部追踪。

• 使用 Logo API 进行品牌研究：Google Cloud Vision 提供了一个独立的标志检测 API，您可以在横幅广告中查找标志以确定品牌名称。

• 店内情感分析：如果我们能实时检测到店内顾客的意见和情感，那么实时营销和客户支持就可以向前迈进一大步。Google Cloud Vision 通过店内用户的面部表情来捕捉顾客的情感。

• 机器人技术：使机器人能够理解其环境是一个巨大的挑战，需要 Google Vision API 进行精确的对象检测。

云视觉的主要领域之一是 Google 的云视觉光学字符识别（OCR），这是一种将手写文本或印刷文本转换为机器编码文本的方法。使用 OCR，Google Vision API 可以识别和从图像中提取文本，有两种标注：文本检测识别并从图像中提取文本，文档文本检测从图像中提取文本，其格式针对密集文本和文档进行了优化。文本检测的 JSON 提取响应包含提取的文本以及该文本中出现的所有单个单词，而文档文本检测的 JSON 提取响应包括页面信息、块、段落和单词，以及页面分页信息。Google Cloud Vision OCR 具有以下优势：

• 多语言支持：Google Cloud Vision OCR 支持许多语言。

• librarysur，并且可以非常容易地使用。

• 快速速度：Google Cloud Storage 平台与 OCR API 服务集成。利用 GCS，OCR API 可以非常快。

• 可扩展性：它可以进行扩展，而 Google 的 OCR 定价策略鼓励用户增加 API 的使用量，因为使用量增加会导致平均价格降低。

使用 Google 的预训练模型，Cloud Vision API 提供了许多机器学习功能，使开发者能够将它们集成到各种应用开发中。OCR 有许多商业用途：银行使用 OCR 来比较报表，医院使用 OCR 将手写表格转换为标准文本填充表格，政府使用 OCR 进行调查反馈收集，等等。

云视频 API

.MOVIE、.MPEG4、.MP4和.AVI。Google Cloud Video API 提供了以下功能：

• 标签检测：它可以检测视频中的实体，并根据请求提供视频片段标注列表、帧标注列表或镜头标注列表。

• 镜头变化检测：它可以通过镜头或场景标注视频，并标注与视频场景相关的对象。

• 文本检测：它可以提供实际文本以及文本在视频中的位置。

• 显式内容检测：它可以标注显式内容并在视频中放置时间戳。

• 对象跟踪：它可以在视频中跟踪多个对象，并提供每个对象在各个帧中的位置。

• 语音转录：它可以捕获视频中的口语单词/句子，并将它们转录成文本。

通过 Google Cloud Video API，开发人员可以对存储在本地或云存储中的视频或直播视频进行标注，以整个视频、每个片段、每个镜头和每个帧的上下文信息进行标注，并开发相关智能应用。

Google Cloud Language API

Google 的云语言 API包括语言翻译和自然语言处理（NLP）。云翻译 API 允许您检测一种语言并将其翻译成另一种语言，因此您只需指定目标语言，因为它会自动检测源语言。NLP 允许您揭示输入文本的结构和含义。它为开发人员或计算机程序提供了一个接口，用于发送请求并获取响应。

Google 的 NLP API 有几种方法来执行文本分析和标注：

• analyzeSentiment方法。情感分析响应字段包括以下内容：

  • -1.0（消极）和1.0（积极），基于文本的整体情感倾向和情感强度，这表示给定文本中（积极和消极）情感的整体强度，介于0.0和+inf之间。文档的情感得分表示文档的整体情绪。文档的情感强度表示文档中情感内容的存在程度。

  • 语言包含文档的语言，要么在初始请求中传递，要么在缺失时自动检测。

  • 句子包含从原始文档中提取的句子列表，以及附加到每个句子的句子级情感值，这些值包含之前描述的得分和强度值。

情感分析表明文档中积极和消极情绪之间的差异，但它不会识别具体的积极和消极情绪。例如，当检测到被认为是愤怒的某物或被认为是悲伤的文本时，分析响应仅表明情绪是消极的，而不是悲伤或愤怒。

• 实体分析：检查给定的文本中已知实体，例如映射到唯一实体的专有名词（特定的人、地点等）或普通名词（也称为名词，如餐厅、体育场等）。实体分析返回一组检测到的实体及其参数，例如实体的类型、实体与整体文本的相关性以及文本中引用同一实体的位置。实体按其显著性分数（反映其与整体文本的相关性）的顺序（从高到低）返回。

• 实体情感分析：结合实体分析和情感分析，试图确定文本中关于实体的情感（正面或负面）。实体情感由每个检测到的实体的数值分数和幅度值表示。然后，这些分数被汇总成一个实体的整体情感分数和幅度。

• analyzeSyntax 方法。句法分析包括以下操作：

  • 句子提取将文本流分解成一系列句子。

  • 标记化将文本流分解成一系列标记，每个标记通常对应一个单词。

  • 自然语言 API 然后处理标记，并使用它们在句子中的位置，为标记添加句法信息。

• classifyText 方法。对于输入文本，Google 的自然语言 API 过滤 classifyText 方法返回的类别，仅包括最相关的类别。

总结来说，通过情感分析、实体分析、实体情感分析、内容分类和句法分析，Google 自然语言 API 的预训练模型可以帮助开发者将自然语言理解应用于他们的应用程序并解决许多业务用例。

Google Cloud 对话 API

Google Cloud 对话 API 提供了一种进行交互式自然语言 AI 对话的方式。它有三个方面：Cloud Dialogflow、Cloud Text-to-Speech 和 Cloud Speech-to-Text：

• Dialogflow 提供了一个自然语言理解平台，您可以在其中设计和集成对话用户界面。

• 文本转语音将文本输入转换为自然人类语音的音频数据。

• 语音转文本将音频或语音输入转换为文本。

Google Cloud Dialogflow 允许您构建虚拟代理和聊天机器人。Dialogflow 分析文本或音频输入，并使用文本或语音进行响应。

意图是 Dialogflow 的核心。意图将最终用户的意图进行分类。当用户添加输入时，Dialogflow 通过使用训练短语——即最终用户可能实际说出的话的例子——来训练模型进行意图分类，训练结果是将短语映射到意图。使用用户意图，Dialogflow 的典型工作流程如下：

1. 最终用户将提供一个输入短语，该短语将被发送到某种类型的代理。代理执行意图分类并将输入短语映射到意图。

2. 从意图中提取相关参数并将操作链接到意图，例如检索银行账户余额。

3. 参数和操作将被发送以创建响应。

4. 响应是返回给最终用户的语音或文本。

Google Cloud 语音转文本允许将 Google 语音识别技术集成到使用 Google 先进 AI 技术的应用程序开发中。Speech-to-Text 有三种主要方法：

• 同步识别：当语音转文本 API 接收到语音音频数据时，它执行数据识别/处理，并在处理完所有音频数据后返回结果，然后再处理下一个请求。

• 异步识别：当语音转文本 API 接收到音频数据输入时，它启动一个长时间运行的操作，并定期轮询识别结果。

• 流式识别：实时音频识别，例如从麦克风捕获实时音频。流式识别在捕获音频的同时提供中间结果，允许结果在用户仍在说话时出现。

语音转文本可以使用几个机器学习模型来转录您的音频文件。谷歌针对特定的音频类型和来源训练了这些语音识别模型。当您向语音转文本发送音频转录请求时，您可以通过指定原始音频的来源来提高您收到的结果。这允许语音转文本 API 使用针对该特定类型来源的语音音频进行识别的机器学习模型处理您的音频文件。

谷歌云文本转语音 API 允许您使用 WaveNet 声音将文本转换为类似人类的声音，WaveNet 通过在音节、音素和单词上产生更类似人类的重音和语调来合成语音。WaveNet 产生的语音音频比其他文本转语音技术更受人们喜爱。

文本转语音使用合成声音从它呈现的文本创建音频。它创建听起来自然的人类语音，作为可播放的音频。除了普通文本外，云文本转语音 API 还可以将语音合成标记语言（SSML）转换为音频。SSML 允许您控制文本转换为语音的方式。

摘要

在本章中，我们介绍了谷歌云机器学习 API 服务：包含视觉和视频 API 的云视觉 API，包含翻译和自然语言处理 API 的云语言 API，以及包含 Dialogflow、语音转文本和文本转语音的云对话 API。这些谷歌预训练的 API 服务为机器学习应用开发提供了最佳的功能和接口，我们还展示了利用谷歌机器学习 API 的一些示例业务用例。

要掌握谷歌机器学习 API 服务，实验室是学习过程中的重要部分，我们在附录 5、“使用谷歌云机器学习 API 实践”中提供了一些机器学习 API 动手演示。请审查并理解所有实践步骤。

在下一章中，我们将讨论在谷歌云中实施机器学习的最佳实践。

进一步阅读

要深入了解本章的学习内容，您可以参考以下链接：

• 视觉人工智能 | 通过机器学习提取图像洞察 | 云视觉 API：

cloud.google.com/vision/

• 视频人工智能 - 视频内容分析 | 云视频智能 API：

cloud.google.com/video-intelligence/

• 语音转文本：自动语音识别:

cloud.google.com/speech-to-text

• 文本转语音：逼真的语音合成:

cloud.google.com/text-to-speech

• Dialogflow:

cloud.google.com/dialogflow/

• 附录 5, 使用 Google Cloud ML API 进行实践

第九章：使用谷歌云 ML 最佳实践

在本章中，我们将讨论在谷歌云中实施机器学习（ML）的最佳实践。我们将通过在 GCP 中实施一个客户训练的 ML 模型开发过程，并提供全程的建议。

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

• ML 环境设置

• ML 数据存储和处理

• ML 模型训练

• ML 模型部署

• ML 工作流程编排

• ML 模型持续监控

本章旨在将我们在这本书中学到的知识整合起来，并将其应用于客户训练的 ML 项目。我们将首先设置 ML 环境。

ML 环境设置

在第四章“开发和部署 ML 模型”的准备平台部分，我们学习了云中的 ML 平台。然后，在第七章“探索谷歌云 Vertex AI”中，我们介绍了 Vertex AI 服务。对于客户训练的模型开发平台，我们推荐Vertex AI Workbench 用户管理的笔记本。让我们从性能、成本和安全的角度来看一下细节。

使用 Vertex AI Workbench 用户管理的笔记本，您有灵活性和选项来实现性能卓越。您可以使用预安装了最新 ML 和数据科学库以及最新加速器驱动程序的现有深度学习虚拟机镜像创建一个实例。根据您的数据、模型和工作负载，您可以选择合适的虚拟机实例类型以适应您的环境并优化性能，从通用计算（E2、N1、N2 和 N2D），到内存优化（M1 和 M2），到计算优化（C2），等等。您还可以基于自定义容器创建笔记本实例，以定制您的 ML 环境。

使用 Vertex AI Workbench 用户管理的笔记本，您可以遵循 GCP 最佳实践并降低成本。与任何谷歌云服务一样，将您的笔记本的虚拟机实例视为灵活且可丢弃的资源；当您在虚拟机实例上训练 ML 模型时，请确保将所有数据存储在云存储或 BigQuery 中，而不是存储在实例的本地存储中，例如持久磁盘，这样您就可以在完成 ML 实验或训练后停止或删除实例。在 ML 模型开发过程中，始终监控虚拟机实例的性能和成本，并根据工作负载进行扩展/缩减，同时利用谷歌的托管实例组（MIGs）。

安全始终是我们需要在云中解决的问题的重要领域。以下是一些最佳安全实践：

• 使用 Vertex AI 工作台用户管理的笔记本，我们建议为数据科学团队的每个成员创建一个用户管理的笔记本实例。如果团队成员参与多个项目，我们建议为该成员使用多个用户管理的笔记本实例，并将每个实例视为一个虚拟工作空间。

• 运行 Vertex AI 需要各种团队的协作，并且确定哪些团队或系统将负责哪些功能非常重要。从网络的角度来看，如果可能的话，应配置用户管理的笔记本使用共享 VPC，以最小化对笔记本实例的访问。还必须启用限制性防火墙规则，以限制对笔记本实例和其他 Vertex AI 资源的访问。

• 对于数据和模型存储，我们还建议将训练数据和训练模型存储在同一项目中，以提高可重复性。在具有多个文件夹和多个项目的 Google 组织中，最佳实践是利用 Google IAM 角色和组。

• 为了数据保护，我们建议使用 Google Cloud 组织策略和数据丢失预防（DLP）工具来保护个人信息（PII）数据。还建议在 Vertex AI 笔记本实例中存储数据时进行数据加密。Vertex AI 支持在其大多数组件中使用客户管理的加密密钥（CMEK）。

现在我们已经了解了环境设置，让我们转向数据存储和处理。

机器学习数据存储和处理

正如我们在第四章“开发和部署机器学习模型”中讨论的，存储数据涉及从各种数据源收集原始数据并将其存储在集中式存储库中。另一方面，数据处理包括数据工程和特征工程。数据工程是将原始数据（源数据形式的数据）转换为准备数据（准备好的数据集，用于输入到机器学习任务中）的过程。特征工程随后调整准备好的数据以创建机器学习模型所期望的特征。

对于结构化数据，我们建议使用Google Cloud BQ来存储和处理。对于非结构化数据，如视频、音频和图像数据，我们建议使用Google Cloud对象存储来存储它们，并使用Google Cloud Dataflow或Dataproc来处理它们。正如我们之前讨论的，Dataflow是一个托管服务，它使用Apache Beam编程模型将非结构化数据转换为二进制格式，可以提高数据摄取性能。Dataproc 是一个托管Apache Spark和Apache Hadoop服务，它利用开源数据工具进行批量处理、查询、流处理和机器学习。

对于需要标记数据集的监督式机器学习，我们推荐使用Google Vertex AI 数据标注服务，特别是对于非结构化数据。从安全角度考虑，我们推荐使用Google Cloud IAM来管理云存储和 BQ 中的数据访问，使用 GCP DLP 来管理 PII 和其他敏感数据，以及使用 GCP 密钥管理服务（KMS）进行数据加密密钥管理。

一旦数据预处理完成，我们建议使用 Vertex AI 管理的数据集来创建您数据和自定义训练模型之间的链接，并提供描述性统计信息以将数据分割成训练、验证和测试子集。

根据机器学习模型的特点，可以在特征工程中利用许多方法。我们推荐使用Vertex AI 特征存储，它可以用于从数据湖中创建新特征，安排数据处理和特征工程作业，将它们导入 Vertex 特征存储进行在线或批量服务，并在数据科学团队内部共享常用特征。

机器学习模型训练

机器学习模型训练是机器学习开发的关键阶段，这就是我们推荐使用 GCP Vertex AI 训练的原因。我们建议使用自动化的 Vertex AI 训练模型增强器来测试不同的超参数配置，而不是手动调整超参数进行多次训练以获得最佳值，并使用Google Vertex AI TensorBoard来跟踪、共享和比较模型指标，如损失函数，以可视化模型图。这允许您比较各种实验以进行参数调整和模型优化。

使用 Vertex AI Workbench 用户管理的笔记本，您可以方便且交互式地开发代码，我们建议将您的代码进行操作化以实现可重复性和可扩展性，并在 Vertex 训练或Vertex AI Pipelines中运行您的代码。

在模型训练后，建议您使用Vertex 可解释 AI来研究和了解特征贡献，并理解您模型的行为。Vertex 可解释 AI 帮助您理解模型输出——它告诉您数据中的每个特征对预测结果贡献了多少。然后，您可以使用这些信息来查看您的模型是否按预期运行，识别模型中的偏差（如果有），并获得一些改进模型和训练数据的想法。

机器学习模型部署

ML 模型部署指的是将模型投入生产。一旦 ML 模型被部署到生产环境中，它就可以用来预测新的数据。我们建议使用 Vertex AI 控制台或 API 来部署训练好的 ML 模型。使用 Vertex AI，我们可以通过批量预测在生产中提供服务；我们建议为您的模型指定合适的硬件，并确定如何将输入传递给模型。使用 Vertex AI，我们还可以通过在线端点预测来提供服务；我们建议使用 Vertex AI Feature Store 的在线服务 API，并开启至少两个节点的自动扩展。

ML 工作流程编排

正如我们在第七章中讨论的，探索 Google Cloud Vertex AI，Vertex AI 管道是一个完全托管的服务，允许您根据需要重新训练模型，以便您能够适应变化并保持性能。我们推荐使用 Vertex AI 管道进行云 ML 工作流程编排。

如果您使用的是Google TensorFlow 框架，我们建议使用TensorFlow Extended来定义您的管道和每个步骤的操作，然后在 Vertex AI 的无服务器管道系统中执行它。TensorFlow 为 Vertex AI 工作流程中的常见步骤提供了预构建的组件，例如数据摄取、数据验证和训练。

如果您使用其他框架，我们建议使用Kubeflow Pipeline，它非常灵活，允许您使用简单的代码构建管道。Kubeflow Pipeline 还提供了 Google Cloud 管道组件，如 Vertex AI AutoML。

ML 模型持续监控

一旦您将模型部署到生产环境中，您需要持续监控模型性能，以确保其按预期运行。我们建议使用 Vertex AI，它提供了两种监控您的 ML 模型的方法：

• 倾斜检测，寻找模型训练和生产数据之间的扭曲程度。

• 漂移检测，寻找生产数据中的漂移。漂移发生在输入和目标的统计属性随时间变化，导致预测随着时间的推移变得越来越不准确。

对于倾斜和漂移检测，我们建议通过提供一个指向您用于训练模型的训练数据的指针来设置模型监控作业，然后调整用于警报的阈值，以测量数据中发生的倾斜或漂移。

您还可以在 Vertex Explainable AI 中使用特征归因来检测数据漂移或倾斜，作为模型性能可能下降的早期指标。例如，假设您的模型最初依赖于五个特征在训练和测试数据中进行预测，但进入生产后，它开始完全依赖于不同的特征。

摘要

在本章中，我们讨论了在 Google Cloud 中实施 ML 的最佳实践，重点关注基于您的数据和代码的定制训练模型。

本章总结了本书的第三部分*，其中我们讨论了从结构化数据训练 ML 模型的 Google BQ 和 BQML，Google ML 训练框架如 TensorFlow 和 Keras，Google ML 训练套件 Vertex AI，Google Cloud ML API 以及 Google Cloud 中的最佳 ML 实践。

在本书的第四部分，我们将通过了解认证的要求并深入研究一些认证的实践问题来为 Google Cloud Certified Professional ML Engineer 认证做准备。

进一步阅读

要了解更多关于本章所涵盖的内容，请查看以下资源：

• www.tensorflow.org/tfx

• www.kubeflow.org/

• cloud.google.com/architecture/ml-on-gcp-best-practices

• cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning

第四部分：完成 GCP ML 认证

在这部分，我们专注于 Google Cloud Professional Machine Learning Engineer 认证。我们介绍了 GCP ML 认证和 Google 的官方指南。我们通过整合从书中学到的知识和技能来研究认证考试问题。

本部分包括以下章节：

• 第十章，实现 GCP ML 认证

第十章：获得 GCP ML 认证

恭喜！您已经走过了所有这些章节，并在 Google Cloud 的机器学习（ML）方面建立了强大的知识库和技能集。现在，是时候整合您所学到的知识，参加 GCP ML 认证考试——我们学习路线图的最后一部分。

Google 专业机器学习工程师认证考试是您成为 Google Cloud 认证机器学习工程师旅程中非常重要的一部分。为了准备和通过考试，您必须复习本书中的所有内容，并深入理解它们，将所有知识点串联起来。

我们建议您采取以下步骤来准备和获得 Google 专业机器学习工程师认证：

1. 阅读官方 Google 机器学习认证考试指南。

2. 阅读本书的所有章节。

3. 完成本书中的所有动手实验室。

4. 练习并复习本章中的所有练习题。

为了让您做好准备，我们提供了一些 ML 认证考试的练习题，以及本章中问题的分析。确保您充分理解每个问题以及所有问题的答案，以及为什么正确答案是正确的，错误答案为什么是错误的。请记住，这里设置的问题只是示例，我们的目标是为您提供一份参考样本。您还需要在互联网上进行更多研究，以达到考试的全面水平。

GCP ML 考试练习题

请仔细、全面地阅读每个问题，并充分理解它。请同时查阅提供的参考链接中的所有相关文档：

• 问题 1：Space Y 正在发射其第一百颗卫星以构建其 StarSphere 网络。他们已经根据现有的 99 颗卫星轨道设计了精确的轨道（发射速度/时间等），以覆盖地球的范围。在第一百次发射后预测 100 颗卫星位置的最好解决方案是什么？

  1. 使用机器学习算法和训练机器学习模型进行预测

  2. 使用神经网络训练模型进行预测

  3. 使用物理定律和实际环境数据建模和预测

  4. 使用线性回归模型进行预测

分析：这是一个机器学习问题框架问题。为了决定机器学习是否是解决问题的最佳方法，我们需要看传统科学建模是否非常困难或不可能解决问题，以及是否存在大量数据。当我们开始时，科学建模将是我们的首选，因为它基于科学和自然法则建立最精确的模型。例如，给定物体的初始位置和速度，以及它的质量和作用在其上的力，我们可以精确预测其在任何时间的位置。对于这个案例，数学模型比任何机器学习模型都要好得多！

为了预测第一百颗卫星的轨道，在这里答案 C 是最佳选择。

参考：在第三章的“机器学习是否是最好的解决方案？”部分，准备机器学习开发

• 问题 2：一家金融公司正在构建一个机器学习模型，基于他们的历史数据集检测信用卡欺诈，该数据集包含 20 个正面样本和 4,990 个负面样本。

由于类别不平衡，模型训练没有按预期进行。最好的解决方法是什么？

1. 数据增强

2. 提前停止

3. 下采样和上权重

4. 正则化

分析：这个问题是关于在准备分类问题时数据不平衡的问题。当数据不平衡时，将非常难以训练机器学习模型并获得良好的预测。我们需要使用下采样和上权重来平衡类别，所以答案是 C。

参考：在第三章的“数据采样和平衡”部分，准备机器学习开发

• 问题 3：一家化学制造商正在使用 GCP 机器学习管道通过排队输入、分析和可视化数据来检测实时传感器异常。你会选择哪个管道？

  1. Dataproc | 人工智能平台 | BQ

  2. Dataflow | AutoML | Cloud SQL

  3. 数据流 | 人工智能平台 | BQ

  4. Dataproc | AutoML | Bigtable

分析：这是一个机器学习管道问题。我们需要了解 Dataflow 和 Dataproc、人工智能平台和 AutoML 之间的区别，以及各种 GCP 数据库：Cloud SQL、Bigtable 和 BQ。

Dataproc 和 Dataflow 是 GCP 数据处理服务，两者都可以处理批量或流数据。然而，Dataproc 是为与 MapReduce（Apache Hadoop、Hive 和 Spark）兼容的工作而设计的，可以在集群上运行。Dataflow 基于并行数据处理，如果你的数据没有与 Spark 或 Hadoop 的实现，它将运行得更好。

人工智能平台涉及“人工执行”的机器学习训练——使用你自己的数据和模型。AutoML 是“自动化”的机器学习训练，使用 Google 的模型和你的数据，无需编码。

在 GCP 数据库/仓库产品中，Cloud SQL 适用于在线事务处理的关系数据，Bigtable 更多用于 NoSQL 事务处理，而 BQ 非常适合分析和可视化数据（与 Data Studio 集成）。

基于此，我们将选择 C 作为答案。

• 问题 4：一家房地产公司，Zeellow，在美国买卖房产业务做得很好。在过去的几年里，他们积累了大量美国房屋的历史数据。

Zeellow 正在使用机器学习训练来预测房价，并且他们通过整合新数据每月重新训练模型。公司不希望在机器学习过程中编写任何代码。哪种方法最适合他们的需求？

1. AutoML 表格

2. BigQuery ML

3. 人工智能平台

4. AutoML 分类

分析：这个问题也是关于自动机器学习（AutoML）和 AI 平台，以及回归和分类之间的区别。由于自动机器学习（AutoML）在机器学习过程中无需编码，并且这是一个结构化数据机器学习问题，因此正确答案是 A。

• 问题 5：数据科学家团队正在为一家大型企业资源规划（ERP）公司的客户服务中心构建一个深度学习模型，该公司拥有许多 ERP 产品和模块。该深度学习模型将输入客户的聊天文本，并在将它们路由到相应的团队之前将它们分类到产品中。公司希望最小化模型开发时间和数据预处理时间。他们应该选择什么策略/平台？

  1. AI 平台

  2. 自动机器学习（Auto ML）

  3. NLP API

  4. Vertex AI 自定义笔记本

分析：这里的关键点是公司希望最小化模型开发时间和数据预处理时间。自动机器学习（AutoML）是最佳选择，因此正确答案是 B。

• 问题 6：一家房地产公司，Zeellow，在美国买卖房产业务做得很好。在过去的几年里，他们积累了大量关于美国房屋的历史数据。

Zeellow 希望利用他们的历史销售数据通过机器学习预测未来的销售。历史数据存储在云存储中。你想要快速实验所有可用数据。你应该如何构建和训练你的模型？

1. 将数据加载到 BigQuery 中并使用 BigQuery ML

2. 将数据转换为 CSV 格式并使用 AutoML Tables

3. 将数据转换为 TFRecords 并使用 TensorFlow

4. 将数据和重构转换为 CSV 格式并使用内置的 XGBoost 库

分析：这里的关键点是，我们需要快速实验存储在云存储中的所有结构化数据集。BQ 和 BQML 是最佳选择，因为其他所有选项都需要很长时间来构建和训练模型。因此，正确答案是 A。

• 问题 7：一家房地产公司，Zeellow，利用他们的历史数据通过机器学习预测未来的销售。每周都有新数据进来，Zeellow 需要确保模型持续重新训练以反映市场趋势。他们应该如何处理历史数据和新的数据？

  1. 只使用新数据进行重新训练

  2. 每周用新数据更新数据集

  3. 当模型评估指标不符合所需标准时，用新数据更新数据集

  4. 每月用新数据更新数据集

分析：模型重新训练是这里的关键术语。由于数据随时间变化，导致训练好的模型变得过时，因此模型重新训练是机器学习过程中的常态。在这种情况下，我们何时需要重新训练模型？答案是当性能指标不符合要求时。我们如何重新训练模型？答案是使用集成数据集，包括现有和新数据。因此，正确答案是 C。

• 问题 8：房地产公司 Zeellow 通过利用其历史数据来预测未来的销售。他们的数据科学团队在半年前在生产环境中训练并部署了一个深度学习模型。最近，由于数据分布的变化，该模型出现了性能问题。

团队正在制定模型重新训练的策略。您有什么建议？

1. 监控数据偏差并重新训练模型

2. 使用较少的模型特征重新训练模型

3. 重新训练模型以修复过拟合

4. 使用每月新来的数据进行模型重新训练

分析：模型重新训练基于数据值偏差，即数据统计属性的重大变化。当检测到数据偏差时，这意味着数据模式正在变化，我们需要重新训练模型以捕捉这些变化。问题没有提到任何过拟合问题，也没有提到特征减少。重新训练策略将是监控数据偏差，并使用新的输入重新训练模型。因此，正确答案是 A。

参考：developers.google.com/machine-learning/guides/rules-of-ml/#rule_37_measure_trainingserving_skew。

• 问题 9：最近的研究表明，当某种癌症 X 在人类肝脏中发展时，通常会有其他可以识别为 CT 扫描图像中的对象 Y 和 Z 的症状。一家医院正在利用这项研究在 CT 图像上使用 (X, Y, Z) 标签图的机器学习模型进行训练。在这种情况下应使用哪些成本函数？

  1. 二进制交叉熵

  2. 类别交叉熵

  3. 稀疏类别交叉熵

  4. 稠密类别交叉熵

分析：正确答案是 B。

在 第五章，理解神经网络和深度学习，成本函数部分，我们讨论了不同成本函数的使用案例。二进制交叉熵用于二分类问题。当您想防止模型对某个特定类别给予更多重视时，最好使用类别熵——这与 one-hot 编码的想法相同。当您的类别互斥时（例如，当每个样本恰好属于一个类别时），稀疏类别熵更为优化。

• 问题 10：贵公司的数据科学团队基于历史数据构建了一个深度神经网络模型，用于预测汽车公司的销售价值。作为一名谷歌机器学习工程师，您需要验证所选特征是否足够好，以供机器学习模型使用。

  1. 使用 L1 正则化训练模型并验证损失保持不变

  2. 使用无正则化的模型进行训练并验证损失保持不变

  3. 使用 L2 正则化训练模型并验证损失在下降

  4. 使用无正则化的模型进行训练，并验证损失接近零

分析：正确答案是 D。

损失函数是模型预测准确度的衡量标准，并用作机器学习训练过程的指标。为了验证构建的模型具有足够的特征，我们需要确保在未使用正则化时，损失函数接近零。

参考：第四章中的正则化部分，开发和部署机器学习模型。

• 问题 11：你公司的数据科学团队基于历史数据构建了一个深度神经网络模型来预测房地产公司的销售额。作为一名谷歌机器学习工程师，你发现该模型有超过 300 个特征，并且你希望删除一些对目标没有贡献的特征。你会怎么做？

  1. 使用可解释人工智能来理解特征贡献并减少非贡献的特征。

  2. 使用 L1 正则化来减少特征。

  3. 使用 L2 正则化来减少特征。

  4. 一次删除一个特征，训练模型，并验证它不会降低模型性能。删除这些特征。

分析：正确答案是 A。这个问题在讨论特征选择，可解释人工智能是理解哪些特征有贡献以及哪些没有贡献的一种方式。重要的是要理解 L1 和 L2 是解决模型过拟合问题的方法，而不是数据工程中的特征选择。

• 问题 12：你公司的数据科学团队基于历史数据构建了一个深度神经网络模型来预测房地产公司的销售额。他们发现模型很好地拟合了训练数据集，但没有拟合验证数据集。你会怎么做来改进模型？

  1. 应用 0.3 的 dropout 参数，并将学习率降低 10 倍。

  2. 应用 0.3 的 L2 正则化参数，并将学习率降低 10 倍。

  3. 应用 0.3 的 L1 正则化参数，并将学习率提高 10 倍。

  4. 调整超参数以优化 L2 正则化和 dropout 参数。

分析：正确答案是 D。

这个问题在讨论避免模型过拟合的技术。虽然 L1/L2 正则化、dropout 参数和学习率都是帮助的方法，但我们必须调整超参数并找到优化的值。这里的提示是，正确答案将适合一般情况，因此不会包含像 0.3、10 等具体的数字。

• 问题 13：你正在为客服中心构建一个深度学习模型。该模型将输入客户的聊天文本并分析他们的情绪。应该使用什么算法来构建这个模型？

  1. MLP

  2. 回归

  3. CNN

  4. RNN

分析：正确答案是 D。

这个问题测试了机器学习/深度学习中使用的不同算法。由于文本处理进行情感分析需要处理序列数据（时间序列），最佳选项是循环神经网络（RNN）。

• 问题 14：一家健康保险公司实时扫描客户的填写索赔表格，并将它们存储在谷歌云存储桶中。他们使用机器学习模型来识别手写文本。由于索赔可能包含个人身份信息（PII），公司政策要求只有授权人员才能访问信息。存储和处理这种流数据的最佳方式是什么？

  1. 创建两个桶，并分别标记为敏感和非敏感。首先将数据存储在非敏感桶中。定期使用 DLP API 扫描它，并将敏感数据移动到敏感桶中。

  2. 创建一个桶来存储数据。仅允许机器学习服务账户访问它。

  3. 创建三个桶——隔离区、敏感和非敏感。首先将所有数据存储在隔离区桶中。然后，定期使用 DLP API 扫描它，并将数据移动到敏感或非敏感桶中。

  4. 创建三个桶——隔离区、敏感和非敏感。首先将所有数据存储在隔离区桶中。然后，一旦文件已上传，触发 DLP API 进行扫描，并将数据移动到敏感或非敏感桶中。

分析：正确答案是 D。

这是一个 PII/私人数据存储和处理的业务用例，一个典型的解决方案是创建三个桶，并利用 DLP 进行扫描，然后将原始数据移动到不同的桶中，并控制它们的访问。

• 问题 15：房地产公司 Zeellow 利用机器学习通过利用其历史数据来预测未来的销售。最近的模型训练能够达到预期的预测准确度目标，但数据科学团队花费了很长时间。他们希望在不影响达到的模型准确度的情况下减少训练时间。团队应该调整哪个超参数？

  1. 学习率

  2. 迭代次数

  3. 缩放层

  4. 批处理大小

分析：正确答案是 C，因为改变其他三个参数将改变模型的预测准确度。

• 问题 16：数据科学团队使用来自汽车制造公司装配线图像构建了一个深度神经网络（DNN）模型来监控和检测缺陷产品。作为谷歌机器学习工程师，你需要测量测试数据集/图像的机器学习模型的性能。以下哪个选项你会选择？

  1. AUC 值

  2. 召回值

  3. 精确度值

  4. 真阳性（TP）值

分析：正确答案是 A，因为它衡量的是预测的排名有多好，而不是它们的绝对值。它是一个分类阈值不变的指标，因此是衡量模型性能的最佳方式。

• 问题 17：数据科学团队使用来自汽车制造公司装配线图像构建了一个深度学习（DL）模型来监控和检测缺陷产品。随着时间的推移，团队在 AI 平台中构建了多个模型版本。作为谷歌机器学习工程师，你将如何比较这些模型版本？

  1. 比较模型版本的平均平均精度

  2. 在训练数据集上比较模型损失函数

  3. 在验证数据集上比较模型损失函数

  4. 在测试数据集上比较模型损失函数

分析：正确答案是 A，因为它衡量了不同模型版本随时间推移的表现：将你的模型作为模型版本部署，然后为该版本创建一个评估作业。通过比较模型版本之间的平均平均精度，你可以找到表现最好的版本。

参考资料：cloud.google.com/ai-platform/prediction/docs/continuous-evaluation/view-metrics#compare_mean_average_precision_across_models。

• 问题 18：数据科学团队正在使用机器学习模型为电子商务网站构建一个推荐引擎，以提高其业务收入，基于用户的相似性。你会选择哪种模型？

  1. 协同过滤

  2. 回归

  3. 分类

  4. 基于内容的过滤

分析：对于这个推荐引擎问题，正确答案是 A。

基于内容的过滤通过使用项目之间的相似性来推荐与用户喜好相似的项目。协同过滤通过用户之间的相似性来提供推荐。问题中指定了“基于用户的相似性”。

参考资料：developers.google.com/machine-learning/recommendation/overview/candidate-generation。

• 问题 19：数据科学团队正在为一家信用卡公司构建一个欺诈检测模型，其目标是尽可能多地检测欺诈，同时尽可能少地产生误报。你将最大化哪个混淆矩阵指标来评估此模型的表现？

  1. 精确度

  2. 召回率

  3. PR 曲线下方的面积

  4. ROC 曲线下方的面积

分析：在这个欺诈检测问题中，它要求你专注于检测欺诈交易——最大化真正阳性率并最小化假阴性——最大化召回率（召回率 = 真阳性 / (真阳性 + 假阴性)）。它还要求你最小化误报（假阳性）——最大化精确度（精确度 = 真阳性 / (真阳性 + 假阳性)）。

因此，既然你想同时最大化精确度和召回率，正确答案是 C（最大化 PR 曲线下方的面积）。

参考资料：machinelearningmastery.com/roc-curves-and-precision-recall-curves-for-imbalanced-classification/。

• 问题 20：数据科学团队正在为一家汽车制造公司构建数据管道，其目标是通过无代码数据 ETL 界面集成其本地设施中存在的所有数据源。您将使用哪个 GCP 服务？

  1. Dataproc

  2. Dataflow

  3. 数据准备

  4. 数据融合

分析：由于问题要求使用无代码界面进行数据集成，因此在这里 Data Fusion 是最佳选择。因此，正确答案是 D。

参考文献: cloud.google.com/data-fusion/docs/concepts/overview#using_the_code-free_web_ui.

• 问题 21：数据科学团队在 BigQuery 中为一家房地产公司构建了一个 TensorFlow 模型，其目标是将其所有数据模型集成到新的 Google Vertex AI 平台。最佳策略是什么？

  1. 从 BigQuery ML 导出模型

  2. 将 BQML 模型注册到 Vertex AI

  3. 将模型导入到 Vertex AI

  4. 使用 AI 平台作为中间阶段

分析：由于问题要求使用 Vertex AI 进行模型集成，该平台允许您在其中注册 BQML 模型，因此正确答案是 B。

参考文献: https://cloud.google.com/bigquery-ml/docs/managing-models-vertex.

• 问题 22：房地产公司 Zeellow 使用机器学习通过利用其历史数据来预测未来的房屋销售价格。数据科学团队需要构建一个模型来根据房屋位置（美国特定城市）和房屋类型预测美国房屋销售价格。在这种情况下，特征工程的最佳策略是什么？

  1. 一个特征交叉：[纬度 X 经度 X 房屋类型]

  2. 两个特征交叉：[分箱纬度 X 分箱房屋类型] 和 [分箱经度 X 分箱房屋类型]

  3. 三个独立的分箱特征：[分箱纬度]、[分箱经度]、[分箱房屋类型]

  4. 一个特征交叉：[分箱纬度 X 分箱经度 X 分箱房屋类型]

分析：将分箱纬度与分箱经度交叉可以使得模型学习到特定城市对房屋类型的影响。它防止纬度的变化产生与经度变化相同的结果。根据分箱的粒度，这个特征交叉可以学习到特定城市的住房影响。因此，正确答案是 D。

参考文献: developers.google.com/machine-learning/crash-course/feature-crosses/check-your-understanding.

• 问题 23：一家健康保险公司实时扫描客户的填写索赔表格，并将它们存储在 Google Cloud Storage 存储桶中。数据科学家团队开发了一个 AI 文档模型来数字化图像。每天结束时，提交的表格需要自动处理。模型已准备好部署。团队应使用什么策略来处理表格？

  1. Vertex AI 批量预测

  2. Vertex AI 在线预测

  3. Vertex AI ML 流程预测

  4. 使用 Cloud Run 触发预测

分析：如问题所述，我们需要在每天结束时运行该过程，这意味着使用 AI 平台或 Vertex AI 进行批处理。正确答案是 A。

• 问题 24：房地产公司 Zeellow 使用 GCP 机器学习来利用其历史数据预测未来的房屋销售价格。他们的数据科学团队大约有 30 名成员，每个成员都使用 Vertex AI 客户笔记本开发了多个模型版本。管理团队成员开发的这些不同模型和不同版本的最佳策略是什么？

  1. 设置 IAM 权限，允许每个成员访问他们的笔记本、模型和版本

  2. 为每个成员创建一个 GCP 项目以实现整洁的管理

  3. 使用 BQ 为每个成员创建一个到其 GCP 资源的映射

  4. 在创建资源时应用标签/标记，以实现可扩展的库存/成本/访问管理

分析：资源标记/标签是管理中等/大数据科学团队机器学习资源的最佳方式。最佳答案是 D。

资源：https://cloud.google.com/resource-manager/docs/tags/tags-creating-and-managing.

• 问题 25：星巴克是一家国际咖啡店，在多个店铺（1, 2, 3…）销售多种产品 A, B, C…，使用独热编码和位置分箱。他们正在开设新店，并希望利用机器学习模型根据历史数据（A1 是店铺 1 产品 A 的销售数据）预测产品销售。遵循将数据分为训练子集、验证子集和测试子集的最佳实践，数据应如何分配到这些子集中？

  1. 将数据随机分配到子集中：

     • 训练集：[A1, B2, F1, E2, ...]

     • 测试集：[A2, C3, D2, F4, ...]

     • 验证集：[B1, C1, D9, C2...]

  2. 将产品随机分配到子集中：

     • 训练集：[A1, A2, A3, E1, E2, ...]

     • 测试集：[B1, B2, C1, C2, C3, ...]

     • 验证集：[D1, D2, F1, F2, F3, ...]

  3. 将店铺随机分配到子集中：

     • 训练集：[A1, B1, C1, ...]

     • 测试集：[A2, C2, F2, ...]

     • 验证集：[D3, A3, C3, ...]

  4. 按照分配店铺的城市对数据组进行聚合，并将城市随机分配到子集中

分析：此问题涉及数据集分割以避免数据泄露。如果我们随机将数据分配到训练集、验证集和测试集，模型将能够学习关于产品的特定特性。如果我们按产品级别划分，使得给定的产品只存在于训练子集、验证子集或测试子集中，那么模型在验证集上获得高准确率将更加困难，因为它需要关注产品特性/质量。因此，正确答案是 B。

参考：https://developers.google.com/machine-learning/crash-course/18th-century-literature.

• 问题 26：您正在使用 Keras 构建一个深度学习模型，其结构如下：

  model = tf.keras.sequential
  model.add(df.keras.layers.Dense(128,activation='relu',input_shape=(200, )))
  model.add(df.keras.layers.Dropout(rate=0.25))
  model.add(df.keras.layers.Dense(4,activation='relu'))
  model.add(df.keras.layers.Dropout(rate=0.25))
  model.add(Dense(2))
  

这个模型有多少个可训练权重？

1. 200x128+128x4+4x2

2. 200x128+128x4+2

3. 200x128+129x4+5x2

4. 200x128x0.25+128x4x0.25+4x2

分析：这个问题正在测试 Keras 模型中可训练权重的概念。如你所见，正确答案是 D。

• 问题 27：数据科学团队正在为一家大型 ERP 公司的客户服务中心构建一个深度学习模型，该公司拥有许多 ERP 产品和模块。公司每天接收超过一百万个客户服务电话，并将它们存储在 GCS 中。通话数据不得离开通话起源地区域，并且不能存储/分析 PII。该模型将分析通话以了解客户情绪。你应该如何设计通话处理、分析和可视化的数据管道？

  1. GCS -> 语音转文本 -> DLP -> BigQuery

  2. GCS -> Pub/Sub -> 语音转文本 -> DLP -> 数据存储

  3. GCS -> 语音转文本 -> DLP -> BigTable

  4. GCS -> 语音转文本 -> DLP -> 云 SQL

分析：由于问题要求一个数据处理、分析和可视化的数据管道，最佳答案是 A。BigQuery 是这里分析和可视化的最佳工具。

• 问题 28：数据科学团队正在构建一个机器学习模型，用于监控和检测汽车制造公司装配线上的图像中的缺陷产品，该公司装配线附近没有可靠的 Wi-Fi。作为一名谷歌机器学习工程师，你需要减少质量检查员使用模型快速缺陷检测所花费的时间。贵公司希望尽快实施新的机器学习模型。你应该使用哪个模型？

  1. AutoML Vision

  2. AutoML Vision Edge 移动多用途-1

  3. AutoML Vision Edge 移动低延迟-1

  4. AutoML Vision Edge 移动高精度-1

分析：由于问题要求快速检查时间和优先考虑延迟降低，正确答案是 C。

参考：cloud.google.com/vision/automl/docs/train-edge。

• 问题 29：一家国家医院正在利用谷歌云和手机应用构建一个机器学习模型，根据年龄、性别、运动、心率、血压等预测心脏病发作。由于健康数据是高度敏感的个人信息，不能存储在云数据库中，你应该如何训练和部署机器学习模型？

  1. 带数据加密的物联网

  2. 联邦学习

  3. 加密 BQML

  4. DLP API

分析：由于限制，联邦学习是这里最佳选择。使用联邦学习，所有数据都被收集，模型通过跨多个去中心化边缘设备（如手机或网站）的算法进行训练，而不需要交换它们。因此，最佳答案是 B。

• 问题 30：你是一家媒体公司的机器学习工程师。你需要构建一个机器学习模型，逐帧分析视频内容，识别对象，并在存在不适当内容时提醒用户。你应该使用哪些谷歌云产品来构建这个项目？

  1. Pub/Sub、云函数和云视觉 API

  2. Pub/Sub、Cloud IoT、Dataflow、Cloud Vision API 和 Cloud Logging

  3. Pub/Sub、Cloud Functions、视频智能 API 和 Cloud Logging

  4. Pub/Sub、Cloud Functions、AutoML 视频智能和 Cloud Logging

分析：由于这个问题涉及视频分析，这将排除 A 和 B。AutoML 视频智能适用于您希望使用 Google 的模型和您的数据进行模型定制的情况。因此，C 是正确答案，因为视频智能 API 可以用来满足这些要求。

概述

在本章中，我们讨论了 Google Cloud 专业机器学习工程师认证考试和一些练习题。由于 GCP ML 是一个不断变化的领域，在本书编写期间，Google 已经开发并发布了许多新服务。本书绝对没有涵盖该领域所有考试主题。您需要参考 Google 认证页面以获取认证考试指南和更新。

本章总结了本书的第四部分。在本书的第五部分中，在附录中，我们将提供一些实验室和演示，以练习您的动手技能。建议您逐个查看每个附录并逐步进行实验室练习。

第五部分：附录

在这部分，我们提供了在 Google Cloud 中进行机器学习的实践操作，包括基本 GCP 服务、Python 数据科学库、scikit-learn 库、GCP Vertex AI 套件和 Google Cloud ML API。

本部分包括以下章节：

• 附录 1，使用基本 GCP 服务进行实践

• 附录 2，使用 Python 数据库进行实践

• 附录 3，使用 Scikit-Learn 进行实践

• 附录 4，使用 Google Vertex AI 进行实践

• 附录 5，使用 Google Cloud ML API 进行实践

附录 1

使用基本 GCP 服务进行实践

在本附录中，我们将展示一些使用 Google Cloud 控制台和 Cloud Shell 的 GCP 资源配置示例。我们将使用以下架构来练习使用 Google Cloud 控制台，如图图 11.1所示：

• 一个 VPC 网络，VPC1，以及其中的两个子网：一个公共subnet1和一个私有subnet2

• 一个具有外部 IP 地址的subnet1，可以从互联网访问

• 一个在私有subnet2中的虚拟机（VM），它没有外部 IP 地址，因此只能通过控制台浏览器或同一 VPC 内的虚拟机访问

• 另一个 VPC 网络，VPC2，以及 VPC2 中的一个子网：一个私有的subnet8

• 私有子网subnet8中的虚拟机（VM）

• VPC1 和 VPC2 之间的对等连接

图 11.1 – GCP 控制台练习的示例架构

在 GCP 实践图 图 11.1 中，public subnet1 可以从互联网访问。有一个名为 B1 的 Google Cloud Storage 存储桶。如果我们想让 VM1、VM2 和 VM8 访问 B1，我们需要做什么？这是一个在继续阅读之前值得思考的好问题。

在云控制台中练习使用 GCP 服务

在 GCP 中，项目是资源分配的基本单元。您可以使用以下步骤开始一个项目：

1. 在您的浏览器中从 GCP 控制台 (console.cloud.google.com) 登录后，您将看到以下起始页面：

1. 您始终可以通过点击 我的第一个项目 旁边的下拉按钮来创建一个新的项目。

在 我的第一个项目 项目中，我们现在将创建网络 VPC、子网和虚拟机。

使用 GCP 控制台创建网络 VPC

使用以下步骤在 GCP 控制台中创建 VPC：

1. 在窗口的右上角，有一个导航下拉菜单，您可以使用它来选择 GCP 服务。

1. 从左侧的导航菜单中，转到 VPC 网络 并从下拉菜单中选择 VPC 网络。它将提示您启用 计算引擎 API。继续并启用它。

您将被带到 VPC 网络 页面，在那里您可以创建 VPC 网络。

1. 点击 创建 VPC 网络。

2. 然后，填写网络详细信息并创建 VPC1：

   • subnet1

   • 10.10.1.0/24

   • us-east1

   • subnet2

   • 10.10.2.0/24

   • asia-east1

然后，vpc1 创建了两个子网：

1. 重复 步骤 3 和 步骤 4 来创建 vpc2：

   • subnet8

   • 192.168.1.0/24

   • europe-central2

您现在创建了两个 VPC：vpc1 包含两个子网，vpc2 包含一个子网。

在 vpc1/subnet1 中使用 GCP 控制台创建公共虚拟机 vm1

使用以下步骤在 GCP 控制台中创建虚拟机：

1. 从左侧的导航菜单中，转到 计算引擎 然后是 虚拟机实例。点击 创建实例 按钮。

然后，填写虚拟机实例的详细信息：

• vm1

• us-east1

• us-east1-b

• 机器配置：通用型，N1 系列

• f1-micro

• subnet1

这在以下屏幕截图中显示：

1. 对于其他选项选择默认设置，然后点击 网络、磁盘、安全、管理、独占租户。

2. 展开网络选项，然后转到 网络接口。

3. 在 vpc1 的 subnet1 Ipv4 (10.10.1.0/24) 对于 子网，并将其他所有内容保留为默认设置。

4. 点击 完成 然后点击 创建。

此时，VM1 已在 vpc1 和 subnet1 (10.10.1.0/24) 中创建，内部 IP 地址为 10.10.1.2，外部 IP 地址为 34.148.1.115。

要允许将 安全外壳协议（SSH）连接到这个 Linux 虚拟机，你需要创建一个防火墙规则以允许传入的 SSH 流量。

1. 从三个点的下拉菜单中选择 查看网络详情。

2. 选择 防火墙，然后选择 创建防火墙规则。

1. 填写防火墙规则详细信息：

   • vpc1-firewall-rule2

   • vpc1

1. 将 22 作为端口号选择 0.0.0.0/0（SSH 使用端口号 22）。然后，点击 创建。

1. 在防火墙规则创建成功后，返回 虚拟机实例 页面。从 SSH 下拉菜单中选择 在浏览器窗口中打开（确保你允许浏览器弹出窗口）。

现在，你能够 SSH 进入虚拟机实例。

现在，你已经在 vpc1 的 subnet1 中创建了一个名为 vm1 的 GCP 虚拟机。

使用 GCP 控制台在 vpc1/subnet2 内创建私有虚拟机 vm2

1. 重复 上一节 中的步骤来在 vpc1/subnet2 中创建一个 VM。唯一的变化如下：

   • 选择 asia-east1 作为 subnet2 所在的区域。

   • 选择 subnet2 作为子网。

   • 对于 外部 IPv4 地址 选择 无，因为这是一个私有虚拟机，没有分配外部 IP 地址。

现在，vm2 已经在 vpc1/subnet2 中配置，IP 地址为 10.10.2.2。

1. 重复 在 vpc1/subnet1 内使用 GCP 控制台创建公共虚拟机 vm1 中的步骤来创建一个防火墙规则，允许 vpc1（10.10.0.0/16）内的 ping，这样 vm1 和 vm2 就可以在同一个 VPC 内 ping 对方。

2. 从 vm1 ping vm2（10.10.1.2）。

在这个时候，你已经在 vpc1 的 subnet2 中创建了一个名为 vm2 的 GCP 虚拟机，并且 vm1 可以 ping vm2。

使用 GCP 控制台在 vpc2/subnet8 内创建私有虚拟机 vm8

重复 在 vpc1/subnet2 内使用 GCP 控制台创建私有虚拟机 vm2 中的步骤来在 vpc2/subnet8（192.168.1.0/24）中创建一个 VM，没有公共 IP 地址。唯一的变化如下：

• 选择 europe-central2 作为 subnet3 所在的区域。

• 选择 subnet8 作为子网。

注意，即使你创建了允许从 vpc1 到 vpc2 进行 ping 的防火墙规则，vm1/vm2 也不能 ping vm8，因为 vpc1 和 vpc2 之间没有路由。这就是为什么我们需要在 vpc1 和 vpc2 之间创建对等连接的原因。

使用 GCP 控制台在 vpc1 和 vpc2 之间创建对等连接

使用以下步骤在 vpc1 和 vpc2 之间创建 VPC 网络对等连接：

1. 从导航菜单中，转到 VPC 网络，然后转到 VPC 网络对等连接。

2. 从 vpc1 到 vpc2 创建 vpc12-peering。

1. 对 vpc2 到 vpc1 的对等连接也做同样的操作，这样现在两个对等连接都将处于活动状态。

2. 从 vm1 ping vm8（192.168.1.2）。

你现在有一个在 vpc2 的 subnet8 中创建的 GCP 虚拟机 vm8，vm1 可以 ping 通 vm8。

从 GCP 控制台创建 GCS 存储桶

使用以下步骤创建 GCS 存储桶：

1. 从导航菜单中，转到 云存储 然后是 存储桶。

1. 在新窗口中，点击 创建存储桶。

1. 为 GCP 存储桶选择一个全局唯一的名称。这里，我们使用 bucket-08282022。在 选择数据存储位置 下选择 区域，并将存储桶区域选择为 us-east1。点击 创建 按钮.

这将带您到存储桶页面，您可以在之前创建的存储桶下创建子文件夹，上传文件或上传文件夹。

到目前为止，我们已经从控制台配置了 GCP 资源（VPCs/子网、VPC 对等连接、虚拟机和存储）。所有这些配置都可以使用 Cloud Shell 完成。在下一节中，我们将提供 Cloud Shell 的 GCP 资源配置命令/脚本。

使用 Google Cloud Shell 配置 GCP 资源

除了使用 GCP 控制台，我们还可以使用 Google Cloud Shell 来配置所有资源。在以下示例中，GCP 架构显示在 图 11.2 中，我们使用 Cloud Shell 命令来配置 GCP 资源，包括网络 VPCs/子网、虚拟机和 VPC 对等连接。请在 Cloud Shell 中练习使用它们，并确保您理解每一步。

图 11.2 – GCP Cloud Shell 实践的示例架构

1. 创建项目、VPC 和子网：

   gcloud projects create test10122021 --folder 464105225938
   gcloud compute networks create vpc1 --project corvel-032021  --subnet-mode=custom
   gcloud compute networks subnets create subnet11 --network=vpc1 --range=10.10.1.0/24 --project corvel-032021 --region us-west1
   gcloud compute networks subnets create subnet12 --network=vpc1 --range=10.10.2.0/24 --project corvel-032021 --region us-east1
   gcloud compute networks create vpc2 --project corvel-032021  --subnet-mode=custom
   gcloud compute networks subnets create subnet2 --network=vpc2 --range=192.168.1.0/24 --project corvel-032021 --region us-central1
   gcloud compute networks create vpc3 --project test10122021  --subnet-mode=custom
   gcloud compute networks subnets create subnet3 --network=vpc3 --range=172.16.1.0/24 --project test10122021 --region us-central1
   

2. 创建虚拟机：

   gcloud compute instances create myvm11 --project corvel-032021 --machine-type=f1-micro --zone=us-west1-a  --subnet=subnet11
   gcloud compute instances create myvm12 --project corvel-032021 --machine-type=f1-micro --network-interface=subnet=subnet12,no-address  --zone=us-east1-b
   gcloud compute instances create myvm2 --project corvel-032021 --machine-type=f1-micro --network-interface=subnet=subnet2,no-address  --zone=us-central1-b
   gcloud compute instances create myvm3 --project test10122021 --machine-type=f1-micro --network-interface=subnet=subnet3,no-address --zone=us-central1-b
   

3. 列出所有虚拟机并记下它们的 IP 地址：

   gcloud compute instances list --project corvel-032021    
   gcloud compute instances list --project test10122021
   

4. 打开 VPC1 的防火墙：

   gcloud compute firewall-rules create fw1 --network vpc1 --allow tcp:22,icmp --source-ranges 0.0.0.0/0 --project corvel-032021
   

5. 从控制台使用 SSH 连接到 myvm11，你应该能够从 vm11 ping 通 vm12。

6. 但如何从 myvm11 ping 通 myvm2 呢？你需要创建 VPC1 和 VPC2 之间的 VPC 对等连接（它们在同一个项目中）：

   gcloud compute networks peerings create peer12 --project=corvel-032021  --network=vpc1 --peer-project=corvel-032021 --peer-network=vpc2
   gcloud compute networks peerings create peer21 --peer-project=corvel-032021  --network=vpc2 --project=corvel-032021 --peer-network=vpc1
   gcloud compute networks peerings list --project=corvel-032021
   

7. 打开 vpc2 的防火墙：

   gcloud compute firewall-rules create fw2 --network vpc2 --allow tcp:22,icmp --source-ranges 0.0.0.0/0 --project corvel-032021
   

8. 现在，你应该能够从 vm11 ping 通 vm2。但如何从 myvm11 ping 通 myvm3 呢？你需要创建 vpc1 和 vpc3 之间的 VPC 对等连接（它们在不同的项目中）：

   gcloud compute networks peerings create peer13 --project=corvel-032021  --network=vpc1 --peer-project=test10122021 --peer-network=vpc3
   gcloud compute networks peerings create peer31 --project=test10122021 --network=vpc3 --peer-project=corvel-032021 --peer-network=vpc1
   gcloud compute networks peerings list --project=corvel-032021
   

9. 打开 vpc3 的防火墙：

   gcloud compute firewall-rules create fw3 --network vpc3 --allow tcp:22,icmp --source-ranges 10.10.1.0/24 --project test10122021
   

现在，你应该能够从 vm11 ping 通 vm3。

摘要

在本附录中，我们提供了从 GCP 控制台配置 GCP 服务/资源的实践示例。我们还展示了如何使用 Google Cloud Shell 创建这些基本资源。

附录 2

练习使用 Python 数据库

在 第二章 精通 Python 编程 中，我们介绍了 Python 数据库，包括 NumPy、Pandas、Matplotlib 和 Seaborn。在本附录中，我们将通过在 Google Colab 平台上使用这些库进行实践来继续学习这些库（colab.research.google.com）。

采用逐步的方法，我们将展示如何使用这些库来管理和可视化数据。对于 NumPy 库，我们将讨论如何生成和操作 NumPy 数组。对于 Pandas 库，我们将涵盖包括 Series、DataFrames、缺失数据处理、GroupBy 和操作等功能。对于 Matplotlib 和 Seaborn 库，我们将通过探索多个数据可视化示例来展示它们的功能。

按照以下示例进行操作，并确保你理解每一个示例。在 Google Colab 上练习每个示例将获得最佳结果。

NumPy

NumPy 是一个为 Python 提供对大型、多维数组和矩阵支持以及大量高级数学函数来操作这些数组的库。

在本节中，我们将讨论以下主题：

• 生成 NumPy 数组

• 操作 NumPy 数组

我们将从如何生成 NumPy 数组开始。

生成 NumPy 数组

在本节中，我们将演示创建 NumPy 数组的各种方法。数组可能是一维的或二维的。

让我们使用以下代码将一个列表转换成一维数组（第一行导入 NumPy 库并将其别名为 np）：

import numpy as np
my_list = [1,2,3]
my_list
[1, 2, 3]
import numpy as np
my_list = [1,2,3]
arr = np.array(my_list)
arr
array([1, 2, 3])

现在，让我们用以下代码使我们的列表变得稍微复杂一些：

import numpy as np
my_mat =[[10,20,30],[40,50,60],[70,80,90]]
np.array(my_mat)
array([[10, 20, 30],
       [40, 50, 60],
       [70, 80, 90]])

注意，有两对括号表示二维数组。

NumPy 中的一个基本函数是 arange()，你可以提供起始值和结束值。例如，以 0 作为起始值，10 作为结束值，np.arange() 将生成一个从 0 到 10（函数中提供的最后一个值不包括在内）的一维数组：

import numpy as np
np.arange(0,10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

让我们使用相同的函数和一些其他值/参数。在以下示例中，我们添加了一个额外的参数，称为步长，以创建一个包含偶数的一维数组：

import numpy as np
np.arange(0,11,2)
array([ 0, 2, 4, 6, 8, 10])

arange 函数的第一个参数是起始值，第二个是结束值，最后一个参数是步长。

NumPy 的另一个内置函数是生成全为零的数组。我们需要提供参数，说明数组中要生成多少个零，如下面的代码片段所示：

import numpy as np
np.zeros(5)
array([0., 0., 0., 0., 0.])

你也可以提供一个元组作为参数：

import numpy as np
np.zeros((4,4))
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

同样，如果我们需要生成一个全为 1 的数组，我们可以使用 ones 函数并提供一个数字作为参数，如下所示：

import numpy as np
np.ones((3,4))
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

另一个有用的内置函数是 linspace，我们输入的第一个参数是第一个数字，最后一个参数是最后一个数字，它们在指定的区间内均匀分布。记住，arange 函数返回起始点和结束点之间的所有整数，但 linspace 还有一个第三个参数，即我们想要的点的数量：

import numpy as np
np.linspace(0,5,10)
array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,
       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])

在上一个示例中，有一个一维数组（用单个括号指定），在 0 和 5 之间有 10 个等间距的点：

import numpy as np
np.linspace(0,5,25)
array([0.        , 0.20833333, 0.41666667, 0.625     , 0.83333333,
       1.04166667, 1.25      , 1.45833333, 1.66666667, 1.875     ,
       2.08333333, 2.29166667, 2.5       , 2.70833333, 2.91666667,
       3.125     , 3.33333333, 3.54166667, 3.75      , 3.95833333,
       4.16666667, 4.375     , 4.58333333, 4.79166667, 5.

注意，使用相同的例子和不同的空间点（25），数组看起来像二维数组，但实际上是一维的，这可以通过数组前只有一个括号来证明。

如果你正在处理线性代数问题，它基本上是一个二维的平方矩阵（行数和列数相同），其中有一个全为 1 的对角线，其余都是 0。这就是为什么它只需要一个数字作为参数：

import numpy as np
np.eye(5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

在这里将要使用的一个最常用的函数是生成包含随机数的数组，如下所示：

import numpy as np
np.random.rand(4,5)
array([[0.44698983, 0.46938684, 0.66609426, 0.95168835, 0.48775195],
       [0.17627195, 0.98549358, 0.69526343, 0.44981183, 0.11574242],
       [0.09377203, 0.35856856, 0.38228733, 0.6129268 , 0.16385609],
       [0.79041234, 0.9281485 , 0.72570369, 0.46438003, 0.3159711 ]])

如果我们需要从标准正态分布中返回，而不是使用rand，我们可以使用randn函数：

import numpy as np
np.random.randn(4)
array([ 1.57461921, -1.47658163, 0.38070033, -1.43224982])

另一个函数是randint，它返回一个介于最低和最高整数值之间的随机整数，这些值作为参数提供（最低值包含在内，最高值不包含）：

import numpy as np
np.random.randint(1,100)
29

如果我们需要在提供的区间内生成特定数量的随机整数，我们需要提供一个第三个参数：

import numpy as np
np.random.randint(1,100,10)
array([29, 7, 33, 85, 83, 34, 5, 50, 53, 39])

现在，让我们进行一些转换。在下面的例子中，我们生成了一个包含 25 个值的二维数组，将其保存在array变量中，然后将其重塑为二维数组：

import numpy as np
array = np.arange(25)
array
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])
array.reshape(5,5)
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

如果我们想获取随机生成的数组中的最大值或最小值，我们可以分别使用array.max()或array.min()函数：

import numpy as np
array = np.random.randint(0,50,10)
array
array([ 2, 8, 31, 2, 25, 34, 49, 8, 49, 42])
array.max()
49
array.min()
2

如果我们想从前面例子中提供的数组中选取单个值（或一组值），我们可以用括号指定，如下所示：

import numpy as np
array = np.random.randint(0,50,10)
array
array([42, 38, 43, 22, 39, 4, 20, 30, 49, 13])
array[3]
22
array[0:4]
array([42, 38, 43, 22])

如果我们想在数组中替换单个值或一组值，我们需要将这些值设置如下所示：

import numpy as np
array = np.random.randint(0,50,100)
array
array([42, 10, 14, 34, 45, 18, 21, 11, 33, 32, 22, 13, 11, 42, 16, 20, 10,
        1, 36, 41, 45, 21, 45, 45, 41,  0, 38, 39, 16, 10, 18, 45, 43, 42,
       23, 31, 20, 14,  9, 46, 44, 33, 24, 35,  6,  6, 26, 13, 20, 20, 28,
       23, 46, 40, 15, 43, 17, 31, 15, 48,  9, 17, 46, 28, 48, 41, 30, 28,
       32, 40, 35,  8, 10,  5, 33, 30,  4, 38, 47, 22, 13, 14, 29,  1, 15,
       48, 18, 48, 18, 21, 45,  9,  6,  1, 31, 28,  5, 42,  8, 28])
array[0:3] = 100
array
array([100, 100, 100,  34,  45,  18,  21,  11,  33,  32,  22,  13,  11,
        42,  16,  20,  10,   1,  36,  41,  45,  21,  45,  45,  41,   0,
        38,  39,  16,  10,  18,  45,  43,  42,  23,  31,  20,  14,   9,
        46,  44,  33,  24,  35,   6,   6,  26,  13,  20,  20,  28,  23,
        46,  40,  15,  43,  17,  31,  15,  48,   9,  17,  46,  28,  48,
        41,  30,  28,  32,  40,  35,   8,  10,   5,  33,  30,   4,  38,
        47,  22,  13,  14,  29,   1,  15,  48,  18,  48,  18,  21,  45,
         9,   6,   1,  31,  28,   5,  42,   8,  28])

正如你所见，索引为0、1和2的值被替换成了100。

操作 NumPy 数组

现在，我们将进一步深入，处理二维数组。在下面的例子中，我们生成了一个包含 25 个随机数的数组，并将其重塑为二维数组。然后显示了一个值，它位于第 1 行第 1 列：

import numpy as np
array = np.random.randint(0,50,25).reshape(5,5)
array
array([[15, 21, 34, 39, 18],
       [42, 41, 28, 24,  2],
       [43, 25, 38, 42, 35],
       [ 3,  4, 27,  2, 49],
       [17,  5, 33, 11, 30]])
array[0:3]
array([[15, 21, 34, 39, 18],
       [42, 41, 28, 24,  2],
       [43, 25, 38, 42, 35]])

以下是一个函数，根据特定条件返回数组的布尔值（True或False）：

import numpy as np
array = np.random.randint(0,50,25).reshape(5,5)
array
array([[47, 25,  1, 33,  7],
       [31, 18,  9, 13, 41],
       [28, 33, 34, 19,  2],
       [ 1, 32, 45, 34, 48],
       [27, 34, 38, 18,  9]])
array > 25
array([[ True, False, False,  True, False],
       [ True, False, False, False,  True],
       [ True,  True,  True, False, False],
       [False,  True,  True,  True,  True],
       [ True,  True,  True, False, False]])

我们还可以对数组应用一些数学运算，如加法、减法、乘法和除法，以及应用一些函数，如sin、cos和log：

import numpy as np
array = np.arange(10)
array
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
array + array
array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
array * 2
array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
np.sin(array)
array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,
       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849])

我们已经展示了使用 NumPy 库的一些例子；有关库的更多信息，请参阅numpy.org/。

Pandas

Pandas 是一个基于 NumPy 构建的开源库。Pandas 允许快速的数据分析和数据准备。它在性能和生产率方面表现卓越。

在本节中，我们将讨论以下主题：

• 序列

• 数据框

• 缺失数据处理

• 分组

• 操作

根据环境的不同，你可能需要先通过命令行或终端运行以下命令来安装 Pandas：

conda install pandas
pip install pandas

我们将首先查看序列数据类型。

序列

Series 是我们将首先与 Pandas 一起使用的第一个主要数据类型。Series 几乎与 NumPy 数组相同。区别在于，使用 Series，可以通过标签对轴标签进行索引。

我们将创建四个不同的 Python 对象并形成一个列表：

import numpy as np
import pandas as pd
labels = ['A', 'B','C']
my_data = [100,200,300]
array = np.array(my_data)
d = {'A':100, 'B':200, 'C':300}
pd.Series(data = my_data)
A    100
B    200
C    300
dtype: int64

默认情况下，如果我们没有指定索引值，它将分配 0, 1, 2, …. 因此，我们可以将这些标签更改为我们之前创建的标签（labels）：

pd.Series(my_data, labels)
A    100
B    200
C    300
dtype: int64

如果您想在 Series 中提供一个字典，您不需要提供索引，因为字典已经有了其键和值：

pd.Series(d)
A    100
B    200
C    300
dtype: int64

Series 可以持有任何数据类型，我们也可以提供标签：

pd.Series(labels, my_data)
100    A
200    B
300    C
dtype: object
Next we will examine Dataframes.

DataFrames

DataFrame 是一个二维带标签的数据结构，具有不同类型的列。在本节中，我们将开始使用 Pandas 构建我们的第一个 DataFrame。在以下示例中，我们使用 NumPy 创建了一个随机数，并使用 Pandas 建立了一个带有标签（行和列）的漂亮视图：

import numpy as np
import pandas as pd 
from numpy.random import randn
np.random.seed(101)
df = pd.DataFrame(randn(5,4),['a','b','c','d','e'],['x','y','z','t'])
df
          x         y          z         t
a     2.706850  0.628133    0.907969  0.503826
b     0.651118  -0.319318  -0.848077  0.605965
c     -2.018168  0.740122    0.528813 -0.589001
d     0.188695  -0.758872  -0.933237  0.955057
e     0.190794  1.978757    2.605967  0.683509

如果您想显示 DataFrame 的特定行，请在括号中指定行的名称：

df['x']
a    2.706850
b    0.651118
c   -2.018168
d    0.188695
e    0.190794
Name: x, dtype: float64

注意，输出是一个 Series，我们之前已经介绍过。如果您想检查输出类型，请使用 type 语法，如下所示：

type(df['x']) 
pandas.core.series.Series

如果您想显示 DataFrame 的多个列，可以在括号中指定它们作为一个列表：

df[['x','y']]
          x         y
a     2.706850    0.628133
b     0.651118   -0.319318
c    -2.018168    0.740122
d    0.188695    -0.758872
e    0.190794     1.978757

DataFrame 的另一个特性是能够向其中添加新列。当添加新列时，我们需要指定新列的值。在以下示例中，我们正在创建一个新列 new，并将 x 和 y 的所有值相加并添加到其中：

df['new'] = df['x'] + df['y']
df
        x            y         z        t         new
a    2.706850    0.628133  0.907969   0.503826   3.334983
b    0.651118   -0.319318  -0.848077  0.605965   0.331800
c    -2.018168   0.740122  0.528813  -0.589001   -1.278046
d     0.188695  -0.758872  -0.933237  0.955057   -0.570177
e   0.190794    1.978757    2.605967   0.683509  2.169552

如果您想删除特定的列或行，可以使用内置的 drop 函数：

df.drop('new', axis=1)
         x           y          z        t
a     2.706850   0.628133   0.907969   0.503826
b     0.651118   -0.319318  -0.848077  0.605965
c     -2.018168  0.740122   0.528813   -0.589001
d     0.188695   -0.758872  -0.933237  0.955057
e     0.190794    1.978757   2.605967  0.683509

如果您需要从特定行获取输出，您可以使用 loc 语法，它代表 location，并且您需要指定一个行名作为参数：

df
         x         y           z          t        new
a    2.706850   0.628133   0.907969   0.503826   3.334983
b    0.651118   -0.319318  -0.848077  0.605965   0.331800
c    -2.018168  0.740122   0.528813  -0.589001   -1.278046
d    0.188695   -0.758872  -0.933237  0.955057   -0.570177
e    0.190794   1.978757   2.605967   0.683509   2.169552
df.loc['a']
x      2.706850
y      0.628133
z      0.907969
t      0.503826
new    3.334983
Name: a, dtype: float64

条件选择也是 Pandas 的一个特性，您可以在 DataFrame 中将数据作为布尔值（True 或 False）调用：

df 
        x           y         z          t         new
a   2.706850   0.628133    0.907969   0.503826   3.334983
b   0.651118   -0.319318   -0.848077  0.605965   0.331800
c   -2.018168   0.740122   0.528813   0.589001   -1.278046
d   0.188695   -0.758872   -0.933237  0.955057   -0.570177
e   0.190794   1.978757    2.605967   0.683509   2.169552
df > 0
       x      y     z      t     new
a    True   True   True   True   True
b    True   False  False  True   True
c    False  True   True   False  False
d    True   False  False  True   False
e    True   True   True   True   True 

缺失数据处理

在我们之前创建的 DataFrame 中，如果我们应用一些条件（例如大于零），小于零的数据将显示为 NaN（空数据）。如果您只想显示没有 null 数据的行和列，请使用 dropna 语法，如下所示：

df
         x         y          z          t        new
a    2.706850   0.628133   0.907969   0.503826   3.334983
b    0.651118   -0.319318  -0.848077  0.605965   0.331800
c    -2.018168   0.740122  0.528813  -0.589001   -1.278046
d    0.188695   -0.758872  -0.933237  0.955057   -0.570177
e    0.190794   1.978757   2.605967   0.683509    2.169552
df[df > 0].dropna()
         x           y        z           t         new
a     2.706850   0.628133  0.907969   0.503826   3.334983
e     0.190794   1.978757  2.605967   0.683509   2.169552

现在，我们将应用一个条件并保存一个新的 DataFrame (new_df)，其中包含大于零的值，如下所示：

new_df = df[df > 0]
new_df
         x         y           z         t        new
a    2.706850   0.628133   0.907969   0.503826  3.334983
b    0.651118      NaN        NaN     0.605965  0.331800
c       NaN     0.740122   0.528813    NaN         NaN
d    0.188695      NaN       NaN      0.955057     NaN
e    0.190794   1.978757    2.605967  0.683509  2.169552

对于没有任何值（NaN）的单元格，我们将用该列所有值的平均值（平均数）替换它们：

new_df['x'].fillna(value=new_df['x'].mean())
a    2.706850
b    0.651118
c    0.934364
d    0.188695
e    0.190794
Name: x, dtype: float64

注意，x 列和 c 行的值不是空值，并替换了值。

GroupBy

GroupBy 允许您根据列将行分组并对它们执行聚合函数。

在下一个示例中，我们将使用字典创建一个新的 DataFrame，如下所示：

import numpy as np
import pandas as pd
data = {'Country': ['USA', 'USA', 'France', 'France','Germany','Germany'],
        'Person': ['Sam','Amy','Carhile','Richard','John','Frank'],
        'Sales': [250, 300, 125, 500, 350, 200]}
df = pd.DataFrame(data)
df
    Country    Person     Sales
0    USA        Sam       250
1    USA        Amy       300
2    France     Carhile   125
3    France     Richard   500
4    Germany    John      350
5    Germany    Frank     200

如果您正在处理一个大的 DataFrame 并且想打印每个国家的销售额总和，请使用 groupby 内置函数，如下所示：

df.groupby('Country').sum()
Country    Sales
France     625
Germany    550
USA        550

操作

在本节中，我们将展示一些实际的数据操作。在接下来的示例中，我们将使用一个 CSV 文件，Salaries.csv（来自www.kaggle.com/kaggle/sf-salaries?select=Salaries.csv）。

在本地计算机上下载文件并将其上传到 Google Colab 后，您可以使用 Pandas 库可视化 DataFrame 并探索数据。

使用 read_csv 函数读取 CSV 文件，如下所示：

import pandas as pd
df = pd.read_csv('Salaries.csv')
df

df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 148654 entries, 0 to 148653
Data columns (total 13 columns):
#   Column            Non-Null Count   Dtype  
---  ------            --------------   -----  
0   Id                148654 non-null  int64  
1   EmployeeName      148654 non-null  object 
2   JobTitle          148654 non-null  object 
3   BasePay           148049 non-null  object 
4   OvertimePay       148654 non-null  object 
5   OtherPay          148654 non-null  object 
6   Benefits          112495 non-null  object 
7   TotalPay          148654 non-null  float64
8   TotalPayBenefits  148654 non-null  float64
9   Year              148654 non-null  int64  
10  Notes             0 non-null       float64
11  Agency            148654 non-null  object 
12  Status            38119 non-null   object 
dtypes: float64(3), int64(2), object(8)
memory usage: 14.7+ MB
df["TotalPay"].mean()
74768.32197169267
df[df["EmployeeName"] == "Joseph Driscoll"]["JobTitle"]
36198    Captain, Fire Suppression
Name: JobTitle, dtype: object

在前面的章节中，我们已经展示了 Pandas 库的基本功能。有关 Pandas 功能的更多信息，请参阅pandas.pydata.org。

Matplotlib

Matplotlib 是 Python 中数据可视化的重要库之一。它是一个出色的二维和三维图形库，用于生成科学图表。

Matplotlib 的一些主要优点如下：

• 通常，简单的图表很容易上手

• 支持自定义标签和文本

• 对图表中每个元素都有很好的控制

• 支持多种格式的输出质量高

• 通常非常易于定制

我们将使用 NumPy 库生成简单数据：

import matplotlib.pyplot as plt
import numpy as np
a = np.linspace(1,10,15)
a
array([ 1.        ,  1.64285714,  2.28571429,  2.92857143,  3.57142857,
        4.21428571,  4.85714286,  5.5       ,  6.14285714,  6.78571429,
        7.42857143,  8.07142857,  8.71428571,  9.35714286, 10.

我们使用 NumPy 库中的 linspace 函数生成数据。我们还可以玩转我们的所有数据（在我们的例子中，它是一个数组），例如，取数组中的每个数字并将其平方：

b = a ** 2
b
array([  1.        ,   2.69897959,   5.2244898 ,   8.57653061,
        12.75510204,  17.76020408,  23.59183673,  30.25      ,
        37.73469388,  46.04591837,  55.18367347,  65.14795918,
        75.93877551,  87.55612245, 100.        ])

我们可以使用 Matplotlib 中的一个简单函数在图表中绘制数据：

plt.plot(a,b)

您可以使用 a 和 b 值重新排列 x 和 y 轴，如下所示：

plt.subplot(1,2,1) 
plt.plot(a,b)
plt.title("Dito training 1")
plt.subplot(1,2,2)
plt.plot(b,a,"r")
plt.title("Dito training 2")

到目前为止，我们已经展示了如何使用 plot 和 subplot 方法进行绘图。现在，我们将深入探讨面向对象的方法，其中我们将对所有内容进行更正式的介绍，即 matplotlib 面向对象 API 方法。在下面的示例中，我们运行一个内置的 figure 函数，它构建一个想象中的空白画布，稍后我们将在这个画布上添加一组图形，使其更加灵活：

import matplotlib.pyplot as plt
fig = plt.figure()
<Figure size 432x288 with 0 Axes>
import matplotlib.pyplot as plt
fig = plt.figure()
axes = fig.add_axes([0.1,0.1,0.8,0.8])

第一步是使用 add_axes 函数在画布上添加轴。括号中的数字表示轴的左侧、底部、宽度和高度。

每个数应在零和一之间，表示百分比，数字表示法：

• 第一个数（0.1）表示从画布左侧的 10%。

• 第二个数（0.1）表示从画布底部的 10%。

• 第三个数（0.8）表示轴从画布（宽度）的百分比。

• 第四个数（0.8）表示轴从画布（高度）的百分比。

在前面的示例中，我们使用 NumPy 生成 a 和 b 值，并使用面向对象的方法在我们的自定义画布/轴上绘制它们，这为我们提供了更多的控制。使用一些其他函数，我们可以为每个轴和标题设置名称，如下所示：

import matplotlib.pyplot as plt
import numpy as np
a = np.linspace(1,10,15)
b = a ** 2
fig = plt.figure()
axes = fig.add_axes([0.1,0.1,0.8,0.8])
axes.plot(a,b)

现在，让我们在同一画布上放置两组图形：

import matplotlib.pyplot as plt
import numpy as np
a = np.linspace(1,10,15)
b = a ** 2
fig = plt.figure()
axes1 = fig.add_axes([0.1,0.1,0.8,0.8])
axes2 = fig.add_axes([0.2,0.5,0.4,0.3])
axes1.plot(a,b)
axes2.plot(b,a)
axes1.set_xlabel("X1 Label")
axes1.set_ylabel("Y1 Label")
axes1.set_title("Title 1")
axes2.set_xlabel("X2 Label")
axes2.set_ylabel("Y2 Label")
axes2.set_title("Title 2")

在下一个示例中，我们在同一张图上绘制了两组数据，并添加了一些标签，使用了label和legend方法：

import matplotlib.pyplot as plt
import numpy as np
a = np.linspace(1,10,15)
b = a ** 2
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(a, a**2, label = 'a squared')
ax.plot(a, a**3, label = 'a cubed')
ax.legend()

我们已经展示了使用 Matplotlib 库的一些示例；对于更详细的信息，请参阅matplotlib.org。

海报恩

海报恩是一个基于 Matplotlib 库构建的统计库，我们所学到的所有 Matplotlib 知识都可以应用于海报恩。

我们将从简单的导入库开始。海报恩的一个有用功能是其内置的数据集。在我们的案例中，我们将使用tips数据集：

import seaborn as sns
tips = sns.load_dataset('tips')
tips.head()

您还可以通过使用.info()函数检查一些其他细节（例如列数、行数和数据类型），如下所示：

    total_bill   tip    sex    smoker  day    time    size
0   16.99       1.01    Female   No    Sun   Dinner    2
1   10.34       1.66    Male     No    Sun   Dinner    3
2   21.01       3.50    Male     No    Sun   Dinner    3
3   23.68       3.31    Male     No    Sun   Dinner    2
4   24.59       3.61    Female   No    Sun   Dinner    4
tips.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 244 entries, 0 to 243
Data columns (total 7 columns):
#   Column      Non-Null Count  Dtype   
---  ------      --------------  -----   
0   total_bill  244 non-null    float64 
1   tip         244 non-null    float64 
2   sex         244 non-null    category
3   smoker      244 non-null    category
4   day         244 non-null    category
5   time        244 non-null    category
6   size        244 non-null    int64   
dtypes: category(4), float64(2), int64(1)
memory usage: 7.4 KB

以下示例展示了一个非常基本的直方图，我们将数据集名称设置为tips和total_bill数据（我们数据集的一列）：

sns.displot(tips['total_bill']) 

sns.displot(tips['total_bill'], kde=True, bins = 40)

之前描述的displot函数有不同的参数可以设置以修改您的图表/直方图。请注意，我们已输入两个参数，kde和bins。

接下来，我们将使用jointplot函数探索不同类型的图表。您需要提供x值、y值和数据名称作为参数，如下所示：

sns.jointplot('total_bill', 'tip', data=tips)

注意，我们提供的参数（total_bill和tips）来自我们导入的数据，它们是列名。这是一个双分布图，中间有一个散点图。随着账单价值的增加，小费价值也增加。jointplot也有其他参数可以帮助您修改图表（默认情况下是散点图，但您也可以传递 hex 参数），如下所示：

sns.jointplot('total_bill', 'tip', data=tips, kind = 'hex')

我们接下来要介绍的海报恩功能/函数是箱形图和小提琴图。这些类型的图表用于显示分类数据的分布。它们以便于比较变量的方式显示定量数据的分布：

sns.boxplot(x='day', y='total_bill', data=tips)

与箱形图不同，小提琴图允许您实际绘制与实际数据点相对应的所有组件，并且它本质上显示了潜在分布的核密度估计：

sns.violinplot(x='day', y='total_bill', data=tips)

通过向violinplot函数添加更多参数，您可以向图表添加不同的功能和细节，如下所示。

sns.violinplot(x='day', y='total_bill', data=tips,
               hue = 'sex', split=True)

到目前为止，我们已经通过几个示例展示了海报恩库的功能。Python 中有很多不同的视觉表示使用海报恩库。请访问海报恩网站(seaborn.pydata.org/index.xhtml)获取更多详细信息。

摘要

在本附录中，我们练习使用 Python 数据库，包括 NumPy、Pandas、Matplotlib 和 Seaborn。彻底理解这些示例将帮助您理解数据库并掌握 Python 编程技能。

附录 3：使用 Scikit-Learn 进行练习

在第三章“准备 ML 开发”和第四章“开发和部署 ML 模型”中，我们讨论了数据准备和 ML 模型开发过程。在本附录中，我们将通过在 Google Colaboratory 平台上使用 scikit-learn 包来练习 ML 建模技能(colab.research.google.com)。

采用逐步方法，我们将向您展示如何利用 scikit-learn 库开发 ML 模型。我们将涵盖以下实践：

• 数据准备

• 回归

• 分类

遵循这些示例并确保您理解每个示例是一个最佳实践。在 Google Colab 上练习每个示例将产生最佳结果。

数据准备

在前面的章节中，我们讨论了用于处理和可视化数据的 Python 库，如 NumPy、Pandas、Matplotlib 和 Seaborn。让我们从简单地导入库开始：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

我们将使用一个只有 4 列和 10 行的简单数据集。

注意到一些列是分类的，而另一些是数值的，其中一些列有缺失值，我们需要修复。数据集.csv文件已上传到 Google Colab。

使用pandas库和read_csv函数，我们读取数据并将其保存到变量dataset中，将前三个列（X）分配给y，作为预测：

dataset = pd.read_csv('Data.csv')
X = dataset.iloc[:,:-1].values
y = dataset.iloc[:, -1].values
print(X)
[['France' 44.0 72000.0]
['Spain' 27.0 48000.0]
['Germany' 30.0 54000.0]
['Spain' 38.0 61000.0]
['Germany' 40.0 nan]
['France' 35.0 58000.0]
['Spain' nan 52000.0]
['France' 48.0 79000.0]
['Germany' 50.0 83000.0]
['France' 37.0 67000.0]]

注意到它有一些缺失值。在 ML 训练过程中，我们需要最小化缺失值的数量，因此您可以选择删除包含缺失数据单元格的行，或者用输入值（例如，该列所有值的平均值）替换缺失值。以下示例是使用该特定列的平均值/平均值填充缺失值：

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X[:, 1:3])
X[:, 1:3] = imputer.transform(X[:,1:3])
print(X)
[['France' 44.0 72000.0]
['Spain' 27.0 48000.0]
['Germany' 30.0 54000.0]
['Spain' 38.0 61000.0]
['Germany' 40.0 63777.77777777778]
['France' 35.0 58000.0]
['Spain' 38.77777777777778 52000.0]
['France' 48.0 79000.0]
['Germany' 50.0 83000.0]
['France' 37.0 67000.0]]

下一步是将分类值转换为数值。在我们的加载的数据集(‘data.cvs’)中，列名为Country，有三个不同的值（France、Spain和Germany）。我们将使用独热编码将其转换为具有二进制值的三个列：

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [0])],
remainder = 'passthrough')
X = np.array(ct.fit_transform(X))
print(X)
[[1.0 0.0 0.0 44.0 72000.0]
[0.0 0.0 1.0 27.0 48000.0]
[0.0 1.0 0.0 30.0 54000.0]
[0.0 0.0 1.0 38.0 61000.0]
[0.0 1.0 0.0 40.0 63777.77777777778]
[1.0 0.0 0.0 35.0 58000.0]
[0.0 0.0 1.0 38.77777777777778 52000.0]
[1.0 0.0 0.0 48.0 79000.0]
[0.0 1.0 0.0 50.0 83000.0]
[1.0 0.0 0.0 37.0 67000.0]]

我们还需要将数据集的最后一个列（其中值仅为Yes或No）编码为零和一：

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y = le.fit_transform(y)
print(y)
[0 1 0 0 1 1 0 1 0 1]

下一步是将它们分成训练集和测试集：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y , test_size = 0.2, random_state = 1)
print(X_train)
[[0.0 0.0 1.0 38.77777777777778 52000.0]
[0.0 1.0 0.0 40.0 63777.77777777778]
[1.0 0.0 0.0 44.0 72000.0]
[0.0 0.0 1.0 38.0 61000.0]
[0.0 0.0 1.0 27.0 48000.0]
[1.0 0.0 0.0 48.0 79000.0]
[0.0 1.0 0.0 50.0 83000.0]
[1.0 0.0 0.0 35.0 58000.0]]
print(X_test)
[[0.0 1.0 0.0 30.0 54000.0]
[1.0 0.0 0.0 37.0 67000.0]]
print(y_train)
[0 1 0 0 1 1 0 1]
print(y_test)
[0 1]

现在我们已经练习了基本的数据处理技能，在开始训练 ML 模型之前，让我们先进行特征缩放。有两种类型的特征缩放：标准化和归一化。目标是使所有特征值都在相同的范围内。让我们检查训练数据：

我们发现前三个行之前已经被编码，所以我们将只对第 4 行和第 5 行应用特征缩放：

from sklearn.preprocessing import StandardScaler
sc  = StandardScaler()
X_train[:, 3:] = sc.fit_transform(X_train[:, 3:])
X_test[:, 3:] = sc.transform(X_test[:, 3:])
print(X_train)
[[0.0 0.0 1.0 -0.1915918438457856 -1.0781259408412427]
[0.0 1.0 0.0 -0.014117293757057902 -0.07013167641635401]
[1.0 0.0 0.0 0.5667085065333239 0.6335624327104546]
[0.0 0.0 1.0 -0.3045301939022488 -0.30786617274297895]
[0.0 0.0 1.0 -1.901801144700799 -1.4204636155515822]
[1.0 0.0 0.0 1.1475343068237056 1.2326533634535488]
[0.0 1.0 0.0 1.4379472069688966 1.5749910381638883]
[1.0 0.0 0.0 -0.7401495441200352 -0.5646194287757336]]

注意，X_train的结果介于-2 和+2 之间（范围非常短）。

回归

现在我们已经拆分了数据集并转换了数据，我们将向您展示如何使用 scikit-learn 库构建机器学习模型。我们将从回归开始，并展示以下示例：

• 简单线性回归

• 多元线性回归

• 多项式/非线性回归

简单线性回归

首先，我们需要准备数据集：

import numpy as pd
import pandas as pd
import matplotlib.pyplot as plt
dataset = pd.read_csv('Salary_Data.csv')
X = dataset.iloc[:,:-1].values
y = dataset.iloc[:, -1].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y , test_size = 0.2, random_state = 1)

现在我们可以开始训练我们的回归模型了。我们需要导入一个类并输入我们的训练数据：

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)

接下来，我们将预测测试集中观察结果：

y_pred = regressor.predict(X_test)

让我们绘制我们的预测数据和实际数据，看看它们有多接近：

plt.scatter(X_train, y_train, color = 'red')
plt.plot(X_train, regressor.predict(X_train), color='blue')
plt.title("Salary vs Experiment (Training Set")
plt.xlabel("Years of Experience")
plt.ylabel("Salary")
plt.show()

plt.scatter(X_test, y_test, color = 'red')
plt.plot(X_train, regressor.predict(X_train), color='blue')
plt.title("Salary vs Experiment (Training Set")
plt.xlabel("Years of Experience")
plt.ylabel("Salary")
plt.show()

如您所见，简单线性回归模型与我们的数据集拟合得很好。

多元线性回归

在本节中，我们将使用另一个数据集，该数据集有多个列作为数据特征，一个作为预测变量：

首先，我们进行数据准备：

1. 导入必要的库和/或类。

2. 将数据集拆分为X（特征）和y（预测变量）。

3. 编码列索引 3（状态名称已转换为二进制值并保存为三个额外的列）。

4. 将数据拆分为训练集和测试集：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
dataset = pd.read_csv('50_Startups.csv')
X = dataset.iloc[:,:-1].values
y = dataset.iloc[:, -1].values
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [3])], remainder='passthrough')
X = np.array(ct.fit_transform(X))
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y , test_size = 0.2, random_state=1)

我们现在可以开始训练我们的模型了：

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)

现在是验证/测试我们模型的时候了。由于我们有四个不同的特征，无法在五维图中绘制它们，所以我们不能像在简单线性回归中那样可视化。然而，我们可以显示两个向量：测试集中的实际利润向量和预测利润向量：

y_pred = regressor.predict(X_test)
np.set_printoptions(precision=2)
print(np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)),1))
[[114664.42 105008.31]
[ 90593.16  96479.51]
[ 75692.84  78239.91]
[ 70221.89  81229.06]
[179790.26 191050.39]
[171576.92 182901.99]
[ 49753.59  35673.41]
[102276.66 101004.64]
[ 58649.38  49490.75]
[ 98272.03  97483.56]]

输出左边的部分表示预测利润，右边的部分表示实际利润。

多项式/非线性回归

在本节中，我们将展示非线性回归的示例，其中目标变量与特征之间的关系不是线性的，即它是多项式的。我们将使用线性模型和非线性模型，并比较它们如何拟合真实数据集。

我们将从数据准备开始：

import numpy as np
import pandas as pd 
import matplotlib.pyplot as plt
dataset = pd.read_csv('Position_Salaries.csv')
X = dataset.iloc[:, 1:-1].values
y = dataset.iloc[:, -1].values

现在，我们将训练两个模型：线性回归和多项式回归。以下示例展示了这两个回归模型：

from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X,y)
from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree = 2)
X_poly = poly_reg.fit_transform(X)
lin_reg_2 = LinearRegression()
lin_reg_2.fit(X_poly, y)

接下来，我们将可视化这两个回归模型。

这就是线性回归：

plt.scatter(X, y, color = 'red')
plt.plot(X, lin_reg.predict(X), color = 'blue')
plt.title("Linear Regression")
plt.xlabel("Position Level")
plt.ylabel("Salary")
plt.show()

然后，这是多项式回归：

plt.scatter(X, y, color = 'red')
plt.plot(X, lin_reg_2.predict(X_poly), color = 'blue')
plt.title("Linear Regression")
plt.xlabel("Position Level")
plt.ylabel("Salary")
plt.show()

如我们所见，多项式回归（我们使用了2的幂）产生了准确的预测。如果我们使用更高的幂，我们将获得更好的结果。在以下示例中，我们将幂改为4（见第 2 行），结果将更好地拟合数据集：

from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X,y)
from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree = 4)
X_poly = poly_reg.fit_transform(X)
lin_reg_2 = LinearRegression()
lin_reg_2.fit(X_poly, y)
plt.scatter(X, y, color = 'red')
plt.plot(X, lin_reg_2.predict(X_poly), color = 'blue')
plt.title("Linear Regression")
plt.xlabel("Position Level")
plt.ylabel("Salary")
plt.show()

到目前为止，我们已经通过练习简单线性回归、多元线性回归和非线性回归来覆盖了回归建模过程。在下一节中，我们将讨论分类模型。

分类

与回归不同，在回归中您预测一个连续的数字，而分类用于预测一个类别。在这里我们将介绍逻辑回归。

我们将使用基于购买者的年龄和薪水的 iPhone 购买历史数据集来预测一个新潜在购买者是否会购买 iPhone。

让我们先进行准备：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
dataset = pd.read_csv('Social_Network_Ads.csv')
X = dataset.iloc[:,:-1].values
y = dataset.iloc[:, -1].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y , test_size = 0.2, random_state=1)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
print(X_train)
[[-0.8  -1.19]
[ 0.76 -1.37]
[ 0.85  1.44]
[-0.51 -1.49]
[-1.49  0.38]
[-1.19  0.55]
[ 1.05 -1.04]
[-0.22 -0.3 ]
[ 0.95 -1.34]
[-1.1  -1.07]
[-0.51  1.97]
[ 2.22 -1.01]
[ 1.44 -1.4 ]
[ 0.07 -0.39]
[-1.19  0.64]
[ 2.02 -0.9 ]
[ 1.15  0.58]
[-0.02  0.29]
[-0.22  0.26]
[-0.32 -0.75]
[-1.68 -0.57]
[ 0.85  0.58]
[-0.61 -1.01]
[ 0.95 -1.13]
[-0.22 -0.54]
[ 0.17  0.82]
[-0.41  1.32]
[ 1.15  0.52]
[ 0.76  0.32]
[ 0.66 -0.87]
[ 0.37 -0.27]
[ 0.46 -0.45]
[-0.22  0.14]
[ 0.37  0.11]
[-1.    0.82]
[-0.71  1.41]
[ 0.37 -0.48]
[ 0.37 -0.48]
[-1.68  0.41]
[ 0.85 -0.81]
[-1.   -1.1 ]
[...]

注意，所有值都在 -3 和 +3 之间。

接下来，我们训练逻辑回归模型：

from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()
classifier.fit(X_train, y_train)

让我们预测一个新的结果。在运行预测脚本之前，让我们查看我们的原始数据集并选择一个随机特征集（在我们的案例中，是 30 岁和 87000 的薪水），结果是 0。

运行预测函数后，结果也是相同的：

print(classifier.predict(sc.transform([[30, 87000]])))
[0]

以下示例展示了测试数据集的实际结果与预测结果的比较，以便我们可以比较训练模型的准确性和效率：

y_pred = classifier.predict(X_test)
print(np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)),1))
[[0 0]
[0 0]
[1 1]
[1 1]
[0 0]
[0 0]
[0 0]
[1 1]
[0 0]
[1 0]
[0 0]
[0 0]
[0 0]
[1 1]
[1 1]
[1 1]
[1 1]
[0 0]
[0 0]
[1 1]
[0 0]
[1 1]
[1 1]
[1 0]
[0 1]
[0 0]
[...]]

前面代码中的输出显示了比较：第一列是预测值，第二列是实际值。为了计算模型的准确性和效率，我们可以将预测中正确数量的总和除以测试数据集中实际数量的总和，并构建其混淆矩阵：

from sklearn.metrics import confusion_matrix, accuracy_score
cm = confusion_matrix(y_test, y_pred)
print(cm)
accuracy_score(y_test, y_pred)
[[41  7]
[ 6 26]]
0.8375

输出显示以下内容：

TP=41
FP=6
FN=7
TN=26

模型的准确性和效率为 83%。

摘要

在本附录中，我们展示了使用 scikit-learn 库进行数据准备和模型开发（回归和分类）的示例。通过了解这些示例和过程，将有助于您理解机器学习概念和流程。

附录 4

使用 Google Vertex AI 进行实践

在 第七章 “探索 Google Cloud Vertex AI” 中，我们讨论了 Google Cloud Vertex AI。本附录包含一些 Google Cloud 控制台中 Vertex AI 的动手教程，步骤详尽。我们将涵盖以下实验室：

• Vertex AI – 启用其 API

• Vertex AI – 数据集

• Vertex AI – 标注任务

• Vertex AI – 训练

• Vertex AI – 预测（Vertex AI 端点）

• Vertex AI – 预测（Vertex AI 批量预测）

• Vertex AI – 工作台

• Vertex AI – 特征存储

• Vertex AI – 管道和元数据

• Vertex AI – 模型监控

您需要按照这些实验室进行练习，以掌握 Vertex AI 的使用并获取实施技能。

Vertex AI – 启用其 API

要开始在 Google Cloud 控制台中使用 Vertex AI，您需要设置一个计费账户并创建一个项目。一旦您创建了项目（Vertex AI – demo documentation），您将进入以下项目主页仪表板：

通过左上角的菜单导航以启动 Vertex AI：

要首次启动 Vertex AI，您需要启用 Vertex AI API。为此，选择一个区域并点击蓝色启用 Vertex AI API按钮：

f

启用 Vertex AI API 后，默认情况下，您将进入 Vertex AI API 仪表板。

Vertex AI – 数据集

我们将在 Vertex AI 中使用的第一个工具是数据集。点击数据集后，您将被带到相应的页面。由于我们正在处理一个全新的项目，没有数据集可以显示。点击创建数据集开始：

输入您数据集的名称，并从以下四个主要类别中选择一个数据集类型来工作：

• 图像:

  • 图像分类（单标签）

  • 图像分类（多标签）

  • 图像目标检测

  • 图像分割

• 表格:

  • 回归/分类

  • 预测

• 文本:

  • 文本分类（单标签）

  • 文本分类（多标签）

  • 文本实体提取

  • 文本情感分析

• 视频:

  • 视频动作识别

  • 视频分类

  • 视频目标跟踪

选择数据集类型后，将在 Google Cloud Storage 中创建一个存储桶作为默认数据集存储库。在这里，您可以指定您的存储桶将在哪个区域创建：

点击创建按钮。您将被带到下一页，在那里您需要指定导入方法。有三种导入数据的方法：

• 从您的计算机上传图片

• 从您的计算机上传导入文件

• 从云存储选择导入文件

要从您的本地计算机选择文件，请点击选择文件按钮：

在出现的页面上，导航到包含您本地计算机上图片的文件夹，然后选择您想要上传到数据集的一个或多个图片。请注意，您每次上传最多可以上传 500 张图片。您上传的图片应该是以下格式之一：

• JPEG

• GIF

• PNG

• BMP

• ICO

如果您需要上传更多图片，您需要点击选择文件按钮并指定您想用于数据集的 Google Cloud 存储桶。

一旦图片上传完毕，您可以在数据集中浏览所有图片并检查它们的状态（它们将是已标记或未标记）。如下面的截图所示，我们总共有 20 张图片，它们都是未标记的（标记任务将在下一节中介绍）：

如果您希望使用其他两种将图片添加到数据集的方法——从您的计算机上传导入文件和从云存储选择导入文件——您可以简单地提供一个指向云存储的链接，如下面的截图所示：

其他三个类别（表格、文本和视频）遵循相同的程序，您必须创建数据集并从您的本地计算机或 Google Cloud Storage 上传文件。您还必须输入数据集名称并从提供的选项中选择一个区域。

Vertex AI – 标注任务

在本节中，您将学习如何在 Vertex AI 中标注数据。在创建的数据集中，有几种标注数据的方法。如果您使用的是小型数据集，您可以手动标注每个数据集。默认情况下，数据集每页只显示 10 个图像。如果您想在一页上看到所有图片，您可以从每页项目数选项中选择一个数字。有三个选项 – 10、50和100：

由于我们还没有创建标签，我们需要定义/创建一个标签名称。点击大脑和脊柱：

在创建/添加新标签后，您可以选择每个单独的图像并对其进行标注，或者进行多次选择并将它们作为一组进行标注（按照从步骤 1到步骤 4的每个步骤）：

在标注所有图像后，您可以通过访问摘要页面来检查是否有任何图像未被标注：

如果您有一个非常大的数据集，您可以创建一个标注任务并将其分配给一个团队来标注数据集。

Vertex AI – 训练

现在您已经有一个标注好的数据集，它已准备好进行模型训练。Vertex AI 提供了不同的方法来训练您的模型：

• AutoML

• 自定义训练（高级）

要开始 AutoML 训练，在 Vertex AI 控制台中，点击训练然后点击页面顶部的创建按钮（在我们的案例中，我们将使用上一节中创建的 MRI 图像数据集进行 AutoML 训练）：

在出现的页面上，您需要为要训练的模型定义一些规格：

• 选择数据集：在这里，您将能够看到您之前创建的所有数据集。

• 标注集：标签存储在称为标注的集合中。您可以更改标注集，以将不同的标签组应用于同一数据集。

在训练方法页面，选择AutoML（这将默认选中）。然后，点击继续：

由于我们正在训练一个新的 ML 模型，我们需要选择训练新模型。但如果您已经有一个训练好的模型并想要重新训练或以现有模型的版本训练模型，请选择训练新版本。

接下来，输入模型的名称并提供描述（描述是可选的）。

在高级选项部分，您将有两个数据拆分选项：随机分配和手动（高级）。在随机分配的情况下，您的数据集将自动随机拆分为训练集、验证集和测试集，使用以下比例：

• 80%

• 10%

• 10%

您可以根据需要更改训练模式中的值。有关更多详细信息，请查看 Google 文档cloud.google.com/vertex-ai/docs/general/ml-use?_ga=2.140326960.-2030104523.1635276817&_gac=1.58794719.1650385127.CjwKCAjwu_mSBhAYEiwA5BBmf84zVxwFEpx-VaeJRusJFGq8rVNEovNnLhJ3vLYGMK3Eao6yJhRY5BoCdKgQAvD_BwE：

点击继续。

在下一页和最后一页，您将被提示在预算部分输入一个金额。在这里，您需要指定用于训练特定模型的最大时间量。点击开始训练选项：

训练完成后，您将收到一封确认邮件，您将能够看到其状态。现在，您可以从训练页面（我们训练模型相同的页面）分析训练好的模型，或者从左侧菜单点击模型并点击您想要分析的模型：

当您点击您想要分析的模型时，您将被提示选择模型的版本。由于我们训练了一个全新的模型，我们只有一个版本。以下截图显示了我们的表格数据集的训练模型摘要：

从这张图表中，您可以查看训练模型的性能，以及我们分类模型的混淆矩阵。

模型训练完成后，是时候部署模型进行预测了。有两种方式可以部署模型：

• Vertex AI 端点

• Vertex AI 批量预测

我们将在接下来的几节中详细讨论这些。

Vertex AI – 预测（Vertex AI 端点）

在本节中，我们将通过 Vertex AI 端点部署我们的模型。部署模型有两种方式：

• 从模型

• 从端点

让我们详细看看这些选项。

通过模型部署模型

从左侧菜单转到模型部分，选择您想要部署的模型，并选择您想要部署的版本（记住，我们只有一个版本，因为我们构建/训练了一个全新的模型）。然后，在页面顶部点击部署 & 测试：

点击部署 & 测试后，您将被带到下一页。在这里，点击蓝色的部署到端点按钮：

通过端点部署模型

从左侧菜单转到端点部分。这样做，您将被导航到一个弹出页面，您需要定义您的端点：

在下一页，您需要指定您想要部署到端点的模型以及模型的版本：

指定计算节点数量，并保留其他设置不变。然后，点击完成然后创建：

完成部署后，您将收到一封电子邮件，说明端点部署的状态。现在，我们可以开始进行预测：

1. 前往模型。

2. 选择您希望使用的模型。

3. 选择模型的版本。

4. 在页面顶部，点击部署 & 测试。

您将进入一个页面，您可以开始尝试/测试您部署的模型。点击蓝色上传图片按钮：

从您的本地驱动器中选择一个图片。该图片将被上传到端点；在页面的右侧，您将看到预测结果。在我们的案例中，我们上传了一张随机图片（spine MARI），预测的准确率几乎达到了 99%：

如果您需要在移动/网络应用程序中使用您的端点，您可以请求一个示例 API。从同一页面，点击示例请求：

从出现的菜单中，根据您的需求，您可以从REST或PYTHON部分复制脚本：

经过几次尝试后，系统将开始根据从端点收集的日志生成图表：

到目前为止，我们已经将我们的模型部署到 Vertex AI 端点。现在，让我们学习如何使用批量预测。

Vertex AI – 预测（批量预测）

当您不需要立即响应，而想通过单个请求从累积的数据中获取预测时，使用批量预测。按照以下步骤为我们之前训练的模型执行批量预测：

1. 从控制台的左侧菜单中转到模型。

2. 点击您想要使用的模型。

3. 点击您想要使用的模型版本。

4. 从顶部菜单中，点击批量预测。

5. 点击蓝色创建批量预测按钮：

点击创建批量预测后，您需要定义一些参数，例如批量预测的名称、来源、输出等。让我们分析每个参数：

• 批量预测名称：为批量预测输入一个名称。

• 选择来源：在此，您需要指定用于批量预测的值的来源。您可以从 BigQuery 表或云存储中的文件中选择。请记住，由于我们使用的是表格数据集，格式必须是 CSV、JSONL 或 TFRecord。

• 批量预测输出：选择输出格式（BigQuery 表、CSV、TFRecord 或 JSONL）并提供路径（BigQuery或云存储）。

• 可解释性选项：可选地，您可以为该模型勾选启用特征归因，以便在输出中获得特征归因。

使用 BigQuery 数据集和我们所创建的表，我们可以创建一个新的批量预测来预测风险等级列：

在定义所有参数后，点击创建；批量预测将开始处理。这个过程需要一些时间来完成，完成后您将收到一封电子邮件。

Vertex AI – 工作台

Vertex AI 工作台是整个数据科学工作流程的单个开发环境。您可以使用 Vertex AI 工作台的基于笔记本的环境来查询和探索数据，开发并训练模型，并将代码作为管道的一部分运行。Vertex AI 工作台提供以下功能：

• 托管笔记本是 Google 管理的环境，具有集成和功能，可以帮助您设置并在一个端到端基于笔记本的生产环境中工作。

• 用户托管笔记本是深度学习 VM 图像实例，具有高度可定制性，因此非常适合需要对其环境有大量控制权的用户。

要启动 Vertex AI 工作台，导航到 Vertex AI 控制台并点击工作台：

如果您是第一次使用 Vertex AI 工作台，您需要启用笔记本 API，您将在点击工作台后收到提示。点击启用：

在这个实验室中，我们将创建一个用户托管笔记本。Vertex AI 提供不同类型的 Jupyter 笔记本，带有各种预安装的库和依赖项。在这个例子中，我们将创建一个简单的 Python 3 笔记本。按照以下步骤操作：

1. 从控制台的左侧菜单中，点击工作台。

2. 在页面顶部点击新建笔记本。

3. 从下拉菜单中，点击Python 3：

从弹出菜单中，您需要通过提供其笔记本名称、区域、区域等来识别笔记本。然后，点击创建：

现在，让我们检查和分析我们之前创建的笔记本以及 Vertex AI 笔记本中可用的功能。Vertex AI 提供一个 Jupyter 笔记本环境。点击打开 JupyterLab，如下截图所示：

您将被导航到一个包含 JupyterLab 环境的新标签页。在页面左侧，您将看到所有您的文件夹。默认情况下，有两个文件夹，但您可以从 GitHub 等不同来源创建、上传或克隆文件夹。在页面右侧，您有笔记本、控制台和其他，其中包含终端、文本文件等选项。在笔记本下点击Python 3。您将被带到一张空白笔记本，您可以使用 Python 开始编程：

在点击左边的 .ipynb 文件（以便您可以在右侧开始输入脚本）后：

通过这样，您已经创建了训练平台，并准备好开始运行 Jupyter 笔记本。

Vertex AI – 特征存储

Vertex AI 中的特征存储是您可以创建实体和特征并添加可以稍后按需使用的值的地方。在本演示中，我们将通过运行一些 Python 脚本来探索在 Jupyter 笔记本中创建带有实体和特征的特征存储。在深入笔记本之前，让我们通过 Google Cloud 控制台创建一个特征存储和实体。从控制台的左侧菜单中，点击特征：

由于我们尚未创建任何特征存储，本节将为空。要创建一个新的实体，请点击页面顶部的创建实体类型：

在弹出菜单中，输入所有必要的信息并点击此处所示的创建按钮：

接下来，我们将创建一个新的笔记本并从 GitHub（github.com/GoogleCloudPlatform/vertex-ai-samples）克隆一个仓库。在创建笔记本并克隆上述仓库后，从cloned文件夹中，转到Vertex-ai-samples | notebooks | official | feature_store并点击gapic-feature-store.ipynb：

安装所有附加包并输入您的项目 ID，如以下截图所示：

在您运行脚本的过程中运行所有脚本（在本演示文档中，我们不会逐行检查，但我们将突出与 Vertex AI 特征存储相关的重要点）。

这些脚本将执行以下操作：

1. 准备输出数据集。它将在 BigQuery 中创建一个数据集来托管输出。

2. 导入库并定义常量。

3. 创建特征存储，以及其实体和特征。

4. 导入值。

在运行所有脚本后，您可以在 Google 控制台中检查创建的特征存储（及其实体和特征）。从控制台，转到Vertex AI，然后从左侧菜单点击特征：

您会注意到我们已经创建了一个包含两个实体（movies和users）的特征存储。每个实体有三个特征。如果您点击提供的任何实体，您将看到有关该特定实体的详细信息（在我们的情况下，实体是movies）：

作为一项完全托管的服务，Vertex AI 特征存储为您提供了一个集中式存储库，用于组织、存储和提供机器学习特征，并允许您的团队在规模上共享、发现和重用机器学习特征。它极大地帮助开发新机器学习应用程序和部署。有关特征存储的更多详细信息，请查看cloud.google.com/vertex-ai/docs/featurestore。

Vertex AI – 管道和元数据

管道可以帮助你自动化和重现你的机器学习工作流程。Vertex AI 将它的机器学习产品整合到 Google Cloud 中，提供无缝的开发体验。以前，使用 AutoML 和自定义模型训练的模型可以通过单独的服务访问。Vertex AI 将两者结合到一个单一的 API 中，以及其他新产品。在这个演示中，我们将使用 Vertex Pipelines 创建和运行机器学习管道。

我们将使用 Vertex AI SDK 并创建一个 Jupyter 笔记本。创建笔记本后，点击OPEN JUPYTERLAB，如图所示：

新的笔记本将在新标签页中打开。克隆仓库(github.com/GoogleCloudPlatform/vertex-ai-samples)。

从克隆的文件夹中，转到Vertex-ai-samples | notebooks | official | pipelines。在点击automl_tabular_classification_beans.ipynb文件后，笔记本将在左侧打开，如图所示：

从提供的笔记本中，阅读概述并查看特定演示的数据集、目标和成本。在执行过程中运行所有命令（我们不会描述每个脚本，但会关注与 Vertex AI Pipeline 相关的主要部分）。

你将要运行的脚本将执行以下操作：

1. 设置项目 ID 和存储桶（所有数据都将存储在这里）。

2. 导入必要的库。

3. 定义常量并创建必要的组件。

4. 创建一个端到端的机器学习管道。这个过程将超过 2 小时，因为它将执行以下任务：

   1. 在 Vertex AI 中创建一个数据集。

   2. 使用 AutoML 训练一个表格分类模型。

   3. 获取此模型的评估指标。

   4. 根据评估指标，它将决定是否使用 Vertex Pipelines 中的条件逻辑部署模型。

   5. 使用 Vertex 预测将模型部署到端点。

创建管道后，要查看和分析它，从 Vertex AI 的左侧菜单中点击Pipelines，如图所示：

点击Pipelines后，你将被带到可以选择要查看的管道的页面。你将看到以下管道图：

如果你点击dataset工件，你会看到创建的 Vertex AI 数据集的详细信息。你可以点击旁边指定的URI链接，进入该数据集的页面：

要检查自定义评估组件生成的结果指标可视化，请点击metrics工件。在你的仪表板的右侧，你将能够看到此模型的混淆矩阵：

要检查从该管道运行创建的模型和端点，请转到automl-beans模型。在那里，你应该看到此模型已部署到端点：

记住，管道中的每个部分都会生成输出，这些输出将被用作下一部分的输入。稍后，如果那些输出/输入需要修改，请从左侧菜单点击元数据按钮：

有了这些，我们已经涵盖了 Vertex AI 管道和元数据。在下一节中，我们将讨论 Vertex AI 的模型监控。

Vertex AI – 模型监控

模型部署后，我们需要对其进行监控，因为数据和环境可能会发生变化，导致模型随时间恶化。应考虑两种监控概念：特征偏差和漂移检测。

在我们的演示文档中，我们将构建一个新的表格数据集并训练模型。在这个例子中，我们将使用女子国际足球比赛结果(www.kaggle.com/datasets/martj42/womens-international-football-results)数据集。

我们创建了一个表格数据集，其中我们上传了一个从 Kaggle 下载的 CSV 文件。以下截图显示了数据集的摘要：

我们还使用 AutoML 方法训练了一个模型，目标列我们使用了中性列，该列有两个值（False或True）。以下截图显示了训练模型的摘要：

使用可解释人工智能，我们可以看到比赛列对我们的模型影响最大：

接下来，我们需要将我们的模型部署到端点。点击此处所示的部署到端点按钮：

在出现的弹出菜单（在右侧）中，填写所有字段：

• 监控作业显示名称：监控作业的名称。

• 监控窗口长度：模型将被监控的小时数。

• 警报电子邮件：输入至少 1 个将接收警报的电子邮件（可以输入多个电子邮件地址）。

• 采样率：采样百分比。

保持其余字段不变，点击继续：

在下一节和最后一节中，您需要指定监控目标（偏差检测或漂移检测）。如果您选择训练-服务偏差检测选项，您需要指定训练数据源和目标列。然而，如果您选择预测漂移检测选项，您需要指定警报阈值。在我们的案例中，我们将选择预测漂移检测。接下来，点击部署按钮：

部署到端点的处理需要一些时间。一旦部署完成，您将收到关于部署通知和状态以及正在创建的监控作业（两封分开的电子邮件）的电子邮件：

前面的屏幕截图显示了模型监控作业请求电子邮件通知。请注意，请求已提交，并基于传入的预测请求。它将被采样并记录以进行分析。

摘要

在本附录中，我们查看了一些基于 Google Cloud Vertex AI 套件的示例，该套件为数据科学家提供端到端服务。我们涵盖了 Vertex AI 数据集、标记任务、训练、预测、Workbench、特征存储、管道、元数据和模型监控。

在下一个附录中，我们将讨论如何使用各种 Google Cloud ML API，包括视觉 API、NLP API、语音转文本 API、文本转语音 API、翻译 API 和 Dialogflow API。

附录 5

练习 Google Cloud ML API

在 第八章 探索 Google Cloud ML API 中，我们探讨了 Google Cloud ML API，这是基于预训练模型由 Google 提供的 API 接口。Google Cloud ML API 包括以下 API，所有这些都将在本附录中作为主题进行介绍：

• Google Cloud 视觉 API

• Google Cloud NLP API

• Google Cloud 语音转文本 API

• Google Cloud 文本转语音 API

• Google Cloud 翻译 API

• Google Cloud Dialogflow API

在本附录中，我们将为这些 API 提供实现示例。让我们开始吧。

Google Cloud 视觉 API

在本附录中，我们将向您展示如何通过 Google Cloud Shell 和 Python SDK 使用视觉 API。

在我们开始使用视觉 API 之前，我们需要从 Google 控制台中启用视觉 API。从控制台的左侧菜单中导航到 视觉 API。点击 视觉 API 后，您将被提示启用 API。在我们的案例中，API 已经启用，如图所示：

我们将首先通过 Google Cloud Shell 使用视觉 API。从 Google 控制台，从右上角点击云壳图标，如图所示：

点击云壳图标后，Shell 终端将出现在控制台底部，如图所示：

现在，让我们看看一些示例，以展示视觉 API 在 Google Cloud Shell 中的工作方式：

• 示例 1 是一棵树的图片：

要将文件上传到 Google Cloud Shell，点击以下屏幕截图中的高亮三个点图标，然后点击 上传：

在出现的页面上，您将被提示上传文件或文件夹。导航到您的浏览器并选择您想要上传的图片 – 在我们的案例中，是 tree.jpeg。在 Google Cloud Shell 中运行以下命令：

gcloud ml vision detect-objects tree.jpeg 

在前面的屏幕截图中，我们可以看到 X 和 Y 值。这些代表物体的角点，并且物体被检测为花朵，置信度为 78%。

• 示例 2 是 Google 标志的图片：

现在，我们将尝试从 Vision API 可用的另一个选项，检测标志。上传 Google 标志的图像，并在 Google Cloud Shell 中输入以下命令：

gcloud ml vision detect-logos glogo.jpeg

您还可以尝试使用其他选项，例如检测同一图像上的文本。它将显示结果，例如每个字符及其在图像上的位置：

gcloud ml vision detect-text glogo.jpeg

注意，前面的截图只显示了部分结果，因为输出很长。

现在，让我们与 Python SDK 和 Vision API 进行交互：

1. 首先，您必须安装 Python 的 Google Cloud Vision API。在 Google Cloud Shell 中使用以下命令：

   pip3 install - -upgrade google-cloud-vision
   

2. 接下来，我们需要一些 Python 代码。以下是一个简单的 Python 脚本，它检测图像中的 Google 标志：

   import io  
   import os
   # import the Google client library
   from google.cloud import vision
   # instantiates a client
   client = vision.ImageAnnotatorClient()
   # provide the name of the image file to annotate
   file_name = os.path.abspath('glogo.jpeg')
   # load the image into memoryview
   with io.open(file_name, 'rb') as image_file:
        content = image_file.read()
   image = vision.Image(content = content)
   # Performs label detection on the image file
   response = client.logo_detection(image=image)
   logos = response.logo_annotations
   for logo in logos:
        print(logo.description + " : " + str(logo.score))
   

在这里，我们已经导入了所有必要的库，然后定义了一个图像名称（与我们之前使用的相同标志图像），使用 Vision API 检测了标志，并打印了结果和得分。

现在，我们需要将 Python 脚本上传到 Cloud Shell。上传 Python 脚本后，我们可以按照以下方式执行它：

python3 main.py
Google: 0.979978402153015 

结果表明，标志是 Google，得分为 0.98，这意味着它有大约 98% 的置信度。

Google Cloud NLP API

Google Cloud NLP API 使用模型来分析文本。有几种方式可以使用 NLP API。在这里，我们将向您展示如何通过 Google Cloud Shell 和 Python SDK 使用 NLP API。

在您可以使用 NLP API 之前，您需要启用它。只需从控制台的左侧菜单导航到自然语言 API，或者在上页顶部的搜索栏中输入 Natural Language API。在到达 NLP API 网页后，您将被要求 启用 API（如果您已经这样做，可以跳过此步骤）。

现在，让我们开始使用 Google Cloud Shell 的 NLP API。点击 Cloud Shell 图标以激活它，并输入以下命令：

gcloud ml language classify-text --content =
'If Roe is overturne, legislatures in 26 states have pending laws indicating that they intent to ban abortions, according to the Guttmacher Institure, a research organization that supports abortion rights. That could leave many women in need of abortion services hunders or thousands of miles away from access to procedure - unaffordable for many.
Corporate America is increasingly being drawn from the political sidelines on the abortion issue in response to pressure from inverstors, customer and employees. Companies are also struggling to attract and retain talent and worry about the impact these states anti-abortion laws could have on their workers.'

作为输出，您将看到基于提供的文本进行的分类结果：

前面的输出显示，它以 98% 的置信度成功识别了 People & Society / Social Issues & Advocacy 中的文本，以及以 89% 的置信度识别了 Sensitive Subjects。

让我们尝试另一个选项——那就是 analyze-sentiment。在这里，我们可以提供一些文本来分析情感。对于这个例子，我们将使用 Google 地图的餐厅评论：

在 Google Cloud Shell 中输入以下命令：

gcloud ml language analyze-sentiment - - content =
"From the minute I walked into the door, the family atmosphere hit me like a wave. The people that manage this place of the highest quality and the food matches it. I had a stromboli which I usually avoid because they turn out gummy and nasty. This place was a complete opposite. The bite of fresh garlic in the crust. The salty nuttiness of the mozzarella, the quality of the pepperoni and thin sliced sausage. Everything deserves the chefs kiss. This restaurant is an hour and half away from my home Greensville but well worth it several time over. I will definitely be back."

分析结果将显示。以下截图显示了部分结果：

您可以滚动查看其详细信息。我们需要了解两个主要概念：幅度（情绪的整体强度——即，要么是积极的，要么是消极的）和得分（文本的整体情感倾向）。

现在，让我们使用 Python SDK 调查 NLP API。还有其他一些 SDK 可用，例如 Java、PHP、Go 等：

首先，我们需要安装 SDK。输入以下命令：

pip install google-cloud-language

您需要凭证才能与 Google Cloud 交互。因此，创建服务帐户，生成并上传密钥，并激活它。我们在这里将跳过此步骤。

接下来，我们需要一些 Python 代码。以下是一个简单的 Python 脚本，用于从给定文本中分析情感：

# Import ghe Google Cloud client library
from google.com import language_v1
#set a client variable
client = language_v1.LanguageServiceClient()
# The text to analyze
text = "We heard great review and thought we finally found a Authentic Classy Italiant Restaurant... WRONG!"
document = language_v1.Document(content=text, type_ = language_v1.Document.Type.PLAIN_TEXT)
#Detects the sentiment of the text
sentiment = client.analyze_sentiment(request={'document':document}).document_sentiment
print("Text: {}".format(text))
print("Sentiment:{}".format(sentiment.score, sentiment.magnitude))

将脚本保存在您的本地计算机上，并以analyze_sentiment.py为文件名上传到 Google Cloud Shell。当所有文件都已上传后，您可以运行.py文件来执行脚本并开始分析过程：

python3 analyze_sentiment.py

使用analyze-sentiment方法，我们可以检索情感值和幅度。我们将让您执行它并获取结果。

NLP API 也可以用于与其他 API 集成，例如Speech-To-Text（STT）API。通过使用 STT API，我们可以将声音/语音文件转换为文本，并应用 NLP API 以及各种方法来分析文本的情感/实体/句法。

Google Cloud Speech-to-Text API

Google Cloud Speech-to-Text API 用于将音频转换为文本。该服务基于深度学习技术，支持 120 种语言和变体。该服务可用于转录音频文件，以及支持语音激活的界面。Cloud Speech-to-Text 自动检测正在说的语言。

首先，我们需要启用 Speech-to-Text API。从左侧菜单中，向下滚动并在页面顶部的搜索栏中点击speech to text。

您将被带到一页，您将在此页面上被要求启用 API。如果您之前已启用，您将看到以下页面：

由于我们打算使用curl向 Speech-To-Text API 发送请求，我们需要生成一个 API 密钥来传递到我们的请求 URL。

创建一个名为request.json的请求文件：

然后，运行以下命令（注意，我们跳过了密钥创建步骤）：

curl -s -X POST -H "Content-Type: application/json" -- data-binay @request.json \ "http://speech.googleapis.com/v1/speech:recognize?key=${API_KEY} > result.json

上述命令调用 Speech-to-Text API，从request.json文件中获取所有变量，使用我们生成的密钥，并将所有结果发送/保存到result.json文件中。要查看result.json文件，请输入以下命令：

cat result.json

上述截图显示了从给定音频文件转换的文本，置信度水平（为 98%），处理时间和文本的语言。

Speech-to-Text 也支持不同的语言。有关支持的语言的更多详细信息，请查看cloud.google.com/speech-to-text/docs/languages。

Google Cloud Text-To-Speech API

Google Cloud Text-to-Speech API 将自然语言文本映射成类似人类的语音。第一步是启用 Text-to-Speech API：

点击 Shell 图标进入 Cloud Shell。在深入 API 之前，检查支持的语音和语言列表。您可以通过以下命令在 Google Cloud Shell 中检查可用的语言和语音：

curl -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
     -H "Content-Type: application/json; charset=utf-8" \
     "https://texttospeech.googleapis.com/v1/voices"

上述命令将列出所有可能的语言和语音，以及它们对应的代码。以下截图显示了列表的一小部分：

接下来，我们需要创建一个名为synthesize-text.json的 JSON 文件，其中我们将指定语言和语音代码，并提供一些我们想要转换为音频的完整文本：

{
     'input':{
     'text':'This is a demo documentation for the Cloud Text-to-Speech API. In this demo documentation we are using the United States English language. The code of the language is: "en-US-Standard-A". Thank you.'
     },
     'voice':{
     'languageCode':'en-us',
     'name':'en-US-Standard-A',
     'ssmlGender':'MALE'
     },
     'audioConfig':{
     'audioEncoding':'MP3'
     }
}

使用以下代码通过curl命令调用 Text-to-Speech API：

curl -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
  -H "Content-Type: application/json; charset=utf-8" \
  -d @synthesize-text.json "https://texttospeech.googleapis.com/v1/text:synthesize" \
  > synthesize-text.txt

运行上述命令后，结果将保存到名为synthesize-text.txt的文件中。

打开synthesize-text.txt文件。您会注意到 Text-to-Speech API 提供了以 base64 编码的音频输出，并将其分配给audioContent字段，如下所示：

{
  "audioContent": "//NExAASGoHwABhGudEACdzqFXfRE4EY3AACkD/zX4ADf/6J/[...]"
}

现在，创建一个名为tts_decode.py的 Python 文件：

import argparse
from base64 import decodebytes
import json
"""
Usage:
     python tts_decode.py --input "synthesize-text.txt" \
     --output "synthesize-text-audio.mp3"
"""
def decode_tts_output(input_file, output_file):
     """ Decode output from Cloud Text-to-Speech.
     input_file: the response from Cloud Text-to-Speech
     output_file: the name of the audio file to create
     """
     with open(input_file) as input:
     response = json.load(input)
     audio_data = response['audioContent']
     with open(output_file, "wb") as new_file:
     new_file.write(decodebytes(audio_data.encode('utf-8')))
if __name__ == '__main__':
     parser = argparse.ArgumentParser(
     description="Decode output from Cloud Text-to-Speech",
     formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument('--input',
                     help='The response from the Text-to-Speech API.',
                     required=True)
    parser.add_argument('--output',
                     help='The name of the audio file to create',
                     required=True)
     args = parser.parse_args()
     decode_tts_output(args.input, args.output)

最后，从 Cloud Shell 运行以下命令：

python tts_decode.py --input "synthesize-text.txt" --output "synthesize-text-audio.mp3"

现在，我们的 MP3 文件已准备就绪。

Google Cloud Translation API

Google 的 Cloud Translation API 允许您翻译超过 100 种语言中的文本。使用 Translation API 有两种方式。从 Google Cloud 控制台的主菜单中，点击搜索栏中的Translation API（位于页面顶部）：

点击仪表板后，您将被提示选择以下三个选项之一：

• AutoML 翻译

• 云翻译 API

• 翻译中心

由于我们将使用curl向 Translation API 发送请求，我们需要生成一个 API 密钥来传递我们的请求 URL。

首先，让我们定义我们的文本。输入TEXT=然后输入任何句子。记住，单词之间的空格不应留空；相反，在每个空格中输入%20。在我们的例子中，我们将输入This is a demo documentation，如下所示：

TEXT = "This%20is%20a%20demo%20documentation"

现在我们已经定义了TEXT变量，输入以下命令，该命令用红色下划线标出：

curl "https://translation.googleapis.com/language/translate/v2?target=ru&key=${API_KEY}&q=${TEXT}"

这是一个指定目标语言（在我们的例子中是ru，代表俄语）的 API 的curl调用。查看cloud.google.com/translate/docs/languages以查看所有支持的语言和 ISO-639-1 代码。

运行提供的命令后，您将看到以下输出：

Google Cloud Translation API 还具有一个功能，可以检测语言并将其翻译成任何支持的语言。

在这个例子中，我们将提供两种不同语言的两种不同文本，如下所示：

TEXT_ONE = "Merhaba%20Dostlar"
TEXT_TWO = "привет%20друзья"

我们需要在单词之间输入%20而不是空格。

定义TEXT_ONE和TEXT_TWO后，运行以下命令以调用 Translation API 进行语言检测：

Curl "https://translation.googleapis.com/language/translate/v2/detect?key=${API_KEY}&q=$"TEXT_TWO}"

这将返回一个置信度在零到一之间的检测到的语言（其中零代表 0%，一代表 100%）：

如我们所见，TEXT_ONE的语言是土耳其语（tr），置信度为 100%，而TEXT_TWO的语言是俄语（ru），置信度同样为 100%。

Google Cloud Dialogflow API

Dialogflow API 用于聊天机器人、交互式语音响应（IVR）以及与人类语音的基于对话的交互。首先，我们需要启用 Dialogflow API：

要开始使用该平台，请在新标签页中输入dialogflow.cloud.google.com/#/logindialogflow.cloud.google.com到您的浏览器中。您可能需要使用您的 Google 账户登录。

您将被带到 Dialogflow 平台。这是 Dialogflow ES（基本）版本。在这里，我们将主要使用其用户界面（UI）。有一个可以输入脚本（如 Google Functions）的区域，这部分将在本演示文档中介绍。

现在，让我们熟悉 Dialogflow 的用户界面。以下截图显示了您首次启动 Dialogflow 平台时将看到的页面：

在 Dialogflow 中，您可以拥有多个代理。如果您之前已经创建了代理，您可以通过点击以下截图所示的向下箭头来检查它们：

在这里，您可以查看所有创建的代理列表，或创建一个新的代理。要创建一个新的代理，请向下滚动到页面底部并点击创建新代理，如图所示：

您将被带到以下页面：

在我们的案例中，我们将我们的新代理命名为Test-Chatbot，并保留所有其他设置不变。现在，点击创建：

一旦您的代理创建完成，您将在左侧看到意图：

此选项有助于您理解用户的意图。然后，我们有实体，它允许您从用户那里获取有用的信息。例如，当有人说出“我想吃个素食披萨”时，聊天机器人可以理解他们想要的是素食披萨而不是普通披萨。

在撰写本文时，知识功能处于测试阶段。您可以使用此功能在 Dialogflow 中创建知识库。

满足是您可以集成 Dialogflow 与其他系统（如您的客户管理系统）的地方。以下截图显示了由 Google Functions 驱动的示例脚本：

现在，让我们学习如何在 Dialogflow 中使用意图。意图是用户想要执行的操作或用户提出的问题。例如，假设他们想要订购披萨、预约或想要了解更多关于您公司的信息。在 Dialogflow 中，我们可以创建一个能够理解用户意图并自动回复的代理。

当你创建一个新的代理（正如我们在这里所做的那样），Dialogflow 会默认创建两个意图：

• 默认欢迎意图

• 默认回退意图

这些可以在下面的截图中看到：

让我们看看默认欢迎意图中有什么内容。要做到这一点，请点击默认欢迎意图。这个意图用于理解问候语，如你好、嗨等：

每个意图由两个主要部分组成：

• 训练阶段

• 响应阶段

训练阶段帮助 Dialogflow 理解用户的意图，而响应阶段涉及 Dialogflow 理解问候语。如果它做到了，它将使用响应部分中提供的某些文本进行响应：

Dialogflow 提供的另一个默认意图是默认回退意图。在这里，当 Dialogflow 无法理解用户时，它将使用默认回退意图中提供的文本之一作为文本响应：

现在，让我们深入了解如何创建意图（如前所述，我们将构建一个用户可以订购披萨的聊天机器人）。

要创建一个新的意图，请点击创建意图，如下所示：

我们将把我们的第一个意图命名为opening_times，如下所示：

点击添加训练短语。这是我们提供用户如何表达其意图的示例：

让我们添加一些训练短语，如下面的截图所示：

接下来，我们需要添加一些响应。点击添加响应，如下所示：

我们在这里只添加一个响应，但请记住，您可以为特定的意图添加多个响应：

当您完成训练短语和响应后，保存它们；它们将自动开始训练代理。Dialogflow 需要训练代理以响应用户的问题。这可能需要几秒钟（如果您有长输入，可能需要几分钟）；训练完成后，您将收到通知。

现在，让我们尝试我们的训练代理。在页面右侧，您将看到一个可以尝试您的训练代理的小部分。

让我们为我们的代理输入一个问题。让我们询问他们今天是否营业，看看我们会得到什么回应：

在这个代理中，我们可以创建多个意图。Dialogflow 将理解使用哪些意图并响应用户的问题。

现在，让我们创建一个新的点披萨意图。点击左侧菜单中的意图，然后点击创建意图。以下截图显示了您可以使用的某些表达式：

现在，提供一个针对问题的单一响应（如果您愿意，可以添加更多响应）：

保存您的意图后，您的代理将被重新训练。让我们测试我们的代理：

注意，用户的短语与训练阶段中的不同，但 Dialogflow 仍然理解意图并给出正确的响应。

如果用户需要提供更多细节，例如披萨的不同配料，那么 Dialogflow 将需要使用尚未创建的实体。因此，我们需要创建一个实体。

从左侧菜单中，点击实体，然后点击创建实体，如下所示：

我们将使用topping作为实体的名称。检查topping：

点击保存。

让我们回到我们的点披萨意图，并创建一个新的带有一些点披萨细节的新训练短语，例如“我想点一份芝士披萨。”

这里有一些额外的点披萨的短语：

注意，当我们键入two时，它会自动检测实体：

@sys.number是 Dialogflow 中的一个内置实体，它可以捕获/识别对话中的数字。还有其他内置实体可以识别电子邮件、地址、电话号码和其他细节。有关更多内置实体的信息，请参阅cloud.google.com/dialogflow/es/docs/reference/system-entities。以下是一些示例：

在我们的案例中，我们正在构建实体，因此我们需要将一些词映射到实体上。这将允许我们看到句子的哪一部分与哪个实体相关。只需从意图部分使用的表达式中选择一个词或短语，并将其分配给已创建的实体，如下所示：

选择实体后，您可以从训练表达式中选择其他单词或短语并将它们映射到该实体：

在这个例子中，我们有两个不同的实体 - @sys.number和@topping：

我们还可以使用更动态的答案来更改或修改响应：

点击保存按钮来训练代理并测试/尝试聊天机器人：

如果用户提供了有关披萨配料的信息，我们需要加强额外的问题来收集该特定信息。在必需部分点击topping旁边的复选框，然后点击定义提示，如下面的截图所示：

添加用户将被问及的问题，如下所示：

点击关闭并保存代理。请注意，您还可以添加更多提示。现在，让我们测试一下代理，它对配料一无所知：

这样，我们就拥有了一个功能非常简单的聊天机器人。但在现实生活中，我们希望继续询问用户是否有其他问题或者他们是否想添加其他项目到当前订单中。在我们的案例中，我们有一个用户订购披萨的聊天机器人。除了询问披萨及其配料外，我们还可以询问他们是否想要另一份披萨或者是否想添加一些饮料。这个功能被称为后续意图。要启用此功能，点击order_pizza意图旁边的添加后续意图，如图所示：

因此，如果用户想要继续添加另一份披萨，他们只需简单地回答是。点击是以添加后续意图：

点击order_pizza - yes部分；您将被带到可以修改该部分内容的页面。

在我们的案例中，我们将更改意图的名称，保留所有训练短语不变（在我们的案例中它们已经足够好使用），并添加一个声明“太好了！您想在披萨上放什么配料？”的响应。然后，点击保存：

但如果用户对这个问题（您想再点一些披萨吗？）回答不，会发生什么？在这种情况下，我们想询问他们是否想在订单中添加饮料。像之前一样，从后续意图中选择不，点击子意图并更改其标题（可选），保留所有训练短语不变，并输入答案，如下面的截图所示：

保存代理后，您可以尝试与机器人聊天。您可以根据您设计的对话架构继续添加后续问题或新的意图。

摘要

在本附录中，我们提供了如何使用各种 Google Cloud ML API 的示例，包括视觉 API、NLP API、语音转文本 API、文本转语音 API、翻译 API 和 Dialogflow API。

第十一章：索引

由于此电子书版本没有固定的页码，以下页码仅作为参考，基于本书的印刷版。

符号

@sys.number 290

A

访问范围 12

会计 11

激活函数

关于 78

LeakyReLU 激活函数 79

ReLU 激活函数 79

选择 80

sigmoid 激活函数 79

softmax 激活函数 80

tanh 激活函数 79

自适应矩估计（Adam）78

算法超参数 70

Apache Beam 119

Apache Hadoop 119

Apache Spark 119

应用程序编程接口（APIs）12, 109

曲线下面积（AUC）67

人工智能（AI）19

人工神经网络（ANN）74, 75

赋值 25

异步识别 114

审计 11

认证 9

认证、授权和审计（AAA）9

授权 9, 10

轴突 74

B

反向传播 76

反向传播 53

BigQuery (BQ)

性价比高 89

完全托管 GCP 服务 89

高度可扩展 89

无服务器 89

BigQuery (BQ)，关键服务

数据分析 90

数据摄取 90

数据存储 90

数据可视化 90

BigQuery ML (BQML)

关于 90, 93

数据准备 91

模型创建 91, 92

模型训练 91, 92

需求 90

参考链接 91

BigQuery ML (BQML)，模型

二元逻辑回归 91

K-means 聚类 91

线性回归 91

多类逻辑回归 91

二元分类

大约 42，58

扩展到多类分类 60

逻辑回归 58, 59

阈值 60

二元分类模型指标

准确率 92

f1_score 92

log_loss 92

精度 92

召回率 92

roc_auc 92

二元交叉熵 77

分箱 47

生物神经元 74

C

分类交叉熵 77

分类值转换 48

中央处理单元（CPU） 5

分类 42, 209-214

云块存储 6

云控制台

GCP 服务，通过 144 练习

云网络附加存储（Cloud NAS） 6

云对象存储 6

云服务提供商（CSP） 109

聚类 43

混淆矩阵 60, 64, 65

容器 14

卷积层 82

卷积神经网络（CNN）

大约 81

卷积层 82

完全连接层 83

池化层 82

成本函数 77

Cruzer 6

定制容器

大约 102

工作流程 102

客户管理的加密密钥（CMEK） 102, 118

D

数据平衡 46

数据库服务范围 16

数据收集 44

数据工程

大约 46

分类值转换 48

数据平衡 46

数据抽样 46

缺失数据，处理 48

数值值转换 47

异常值处理 49

DataFrame 178,-81

数据处理

缺失 181, 182

数据准备 197-200

Dataproc 119

数据准备就绪 43, 44

数据抽样 46

数据集

分割 52

测试 52

训练 52

验证 52

数据集 100

决策树 62, 63

深度学习 77

树突 74

Dialogflow

关于 113

工作流程 114

Dialogflow UI

URL 277

词典 28

有向无环图 (DAG) 95

判别模型 (D) 84

文档文本检测 111

下采样 46

漂移检测 121, 253

E

端点部分

模型，通过 231-236 部署

企业资源规划 (ERP) 128

ETL 流程

数据质量 45

数据安全 45

数据大小 45

提取、转换和加载 (ETL) 45

F

假阴性 (FN) 64

假阳性 (FP) 64

假阳性率 (FPR) 65

特征工程

关于 49

特征选择 49

特征合成 50

特征缩放 201

特征选择

关于 49

过滤方法 49

包装方法 49

特征偏差 253

特征合成 50

文件存储 6

过滤方法 49

后续意图 293

前向传播 53，76

完全连接层 83

功能 API 97

函数调用 29

G

GCE 虚拟机定价

参考链接 13

GCP 人工智能服务

关于 19

Google Cloud ML APIs 20，21

Google Vertex AI 20

GCP 大数据和分析服务

关于 17

Google Cloud BigQuery 18

Google Cloud Dataflow 18

Google Cloud Dataproc 18

Google Cloud Pub/Sub 19

GCP Cloud Run 15

GCP 云 Shell

资源，使用 6，7 管理

GCP 计算服务

关于 12

GCE 虚拟机 13

负载均衡器(LBs) 13

管理实例组(MIGs) 13，14

GCP 控制台

GCS 存储桶，从 162-164 创建

URL 144

用于在 vpc1/subnet2 中创建私有虚拟机(vm2) 156-159

用于在 vpc2/subnet8 中创建私有虚拟机(vm8) 159

用于在 vpc1/subnet1 中创建公共虚拟机(vm1) 148-156

用于创建 VPC 网络 145，147

GCP 控制台实践

架构 144

GCP 身份和访问管理

关于 9

审计或会计 11

认证 9

授权 9，10，11

服务账户 12

GCP 机器学习认证 126

GCP 区域

关于 4

参考链接 4

GCP 资源

配置，使用 Google Cloud Shell 164-166

GCP 服务

使用，用于在云控制台中练习 144

GCP 存储 16

GCS 存储桶

创建，从 GCP 控制台 162-164

生成对抗网络 (GANs) 84, 85

生成模型 (G) 84

Google 4

Google Cloud 119

Google Cloud BigQuery 18, 19, 119

Google Cloud Bigtable 17

Google Cloud Conversation API

Dialogflow 113

文本转语音 113

文本转语音 113

Google Cloud Dataflow 18, 119

Google Cloud Dataproc 18

Google Cloud Dialogflow API

关于 276-280

实体，创建 288-295

意图，创建 281-287

Google Cloud IAM 119

Google Cloud ML APIs

关于 20

Google Cloud Conversational API 21

Google Cloud Language API 21

Google Cloud Sight API 20

Google Cloud NLP API 265-268

Google Cloud Platform (GCP)

Cloud Functions 15

计算机，配置 5

免费层账户，创建 5

全球基础设施 4

网络连接，使用虚拟私有云 7

组织结构 7

项目 9

资源层次结构 8

从 4 开始

存储，配置 5, 6

Google Cloud Pub/Sub 19

Google Cloud Shell

使用，用于配置 GCP 资源 164-166

Google Cloud Sight API 109

Google Cloud Spanner 16

Google Cloud Speech-to-Text API 268, 270

Google Cloud SQL 16

Google Cloud Storage (GCS) 6, 16

Google Cloud Text-to-Speech API 270-273

Google Cloud Translation API 273-276

Google Cloud Video API

关于 111, 112

明显内容检测 111

标签检测 111

对象跟踪 111

场景变化检测 111

语音转录 112

文本检测 111

Google Cloud Vision API

关于 110, 111, 259-264

内容检测 110

图像标签检测 110

地标检测 110

标志检测 110

Google Cloud Vision API，用例

使用标志 API 进行品牌研究 110

店内情感分析 110

机器人技术 110

安全和监控 110

文本数字化 110

Google Cloud Vision OCR

易用性 111

快速速度 111

多语言支持 111

可扩展性 111

Google Kubernetes Engine (GKE) 15

Google NLP API 方法

内容分类 113

实体分析 113

实体情感分析 113

情感分析 112

句法分析 113

Google TensorFlow 框架 120

Google Vertex AI

关于 20, 99

参考链接 20

Google Vertex AI 数据标注 119

Google Vertex AI TensorBoard 119

梯度下降 (GD) 78

梯度下降 56, 57

图形处理单元 (GPU) 96

GroupBy 182, 183

分组 43

H

硬盘驱动器（HDDs） 5

超参数调整 69, 70

超参数调整，用于模型创建语句

参考链接 93

I

IAM 角色

自定义角色 10

预定义角色 10

基础（基本）角色 10

身份和访问管理（IAM） 9

意图

关于 114, 280

创建 281-287

响应阶段 282

训练阶段 282

交互式语音响应（IVR） 276

J

Jupyter Notebook

关于 101

管理笔记本 101

用户管理的笔记本 101

K

Keras

关于 96-98

功能 API 97

顺序 API 96

内核（K） 82

Kubeflow 105

Kubeflow DSL 105

Kubeflow Pipeline 120

Kubernetes Pod 15

L

支持云语音识别的语言

参考链接 270

支持的云翻译语言

参考链接 275

层 96

LeakyReLU 激活函数 79

线性回归

关于 53

扩展，到多个特征（变量） 57, 58

扩展，到非线性回归 58

梯度下降 56, 57

单变量回归 54, 56

列表 28

长短期记忆（LSTM）网络 83, 84

M

机器学习（ML）

关于 117

数据处理 119

数据存储 119

环境设置 117, 118

工作流编排 120

Matplotlib

关于 34, 185-190

优点 185

URL 190

均方绝对误差 (MAE) 55, 77

均方误差 (MSE) 55, 77

缺失数据

处理 48

机器学习模型

AUC 65, 67

二元分类 58

分类度量 67

混淆矩阵 64, 65

持续监控 120, 121

决策树 62, 63

部署 70, 120

开发，使用 scikit-learn 进行实践 71

超参数调整 69, 70

线性回归 53

过拟合 68

随机森林 62, 63

正则化 68, 69

ROC 65, 66

支持向量机 (SVM) 60, 61

测试 70

训练 52

欠拟合 68

验证 63

机器学习模型训练

约 119

执行，使用神经网络 76

机器学习平台

准备 52

机器学习问题

最佳解决方案 41, 42

类别 42, 43

定义 41

输入和输出 43

机器学习过程

业务需求 40

机器学习解决方案

衡量 43

性能度量 43

模型超参数 69

模型部分

模型，通过 231 进行部署

多类分类 42

多因素认证 (MFA) 9

多层感知器 (MLP) 81

多元线性回归 204-206

N

自然语言处理 (NLP) 109

自然语言理解 (NLU) 21

网络附加存储 (NAS) 6

网络接口卡 (NIC) 5

神经网络

关于 73, 74

层 75

用例 80

使用，以执行机器学习模型训练 76

名义值 113

非线性回归 206-209

数值 Python (NumPy)

关于 34, 169

URL 176

数值值转换

关于 47

分桶 47

特征裁剪 47

日志缩放 47

范围缩放 47

NumPy 数组

生成 169-175

操作 175, 176

O

one-hot 编码 48

操作 183, 185

光学字符识别 (OCR) 111

优化算法 78

异常值处理 49

P

pandas

关于 34, 177

DataFrame 178-181

数据处理，缺失 181, 182

GroupBy 182, 183

操作 183, 185

系列 177, 178

URL 185

参数化测试。参见测试生成函数

感知器 74

性能卓越

实现 118

持久磁盘 (PD) 6

可识别个人信息 (PII) 45, 131

像素值 80

存在点 (POP) 4

多项式回归 206-209

池化层 82

私有虚拟机 (vm2)

创建，在 vpc1/subnet2 使用 GCP 控制台 156, 157, 159

私有虚拟机 (vm8)

创建，在 vpc2/subnet8 使用 GCP 控制台 159

公共虚拟机 (vm1)

在 vpc1/subnet1 中创建，使用 GCP 控制台 148-156

Python

关于 24, 25

条件和循环 29

数据库和包 33

数据结构 27, 28

文件，打开和关闭 30, 31

函数 29, 30

问题 31-33

变量和运算 25-27

Python，数据库和包

Matplotlib 34

数值 Python (NumPy) 34

pandas 34

Seaborn 34

Q

量子处理器 (QU) 96

R

随机存取存储器 (RAM) 5

随机分类器 66

随机森林 63

接收器操作特征 (ROC) 曲线 65, 66

循环神经网络 (RNN)

关于 83, 131

缺点 83

降低成本 118

回归

关于 42

多元线性回归 204-206

非线性回归 206-209

多项式回归 206-209

简单线性回归 202-204

强化学习 (RL)

关于 43

参考链接 43

ReLU 激活函数 79

RMSProp 78

S

scikit-learn

关于 71

用于练习机器学习模型开发的 71

Seaborn

关于 34，190，192-196

URL 196

安全壳 (SSH) 153

安全 118

情感分析，响应字段

文档情感 112

语言 112

句子 112

顺序 API 96

级数 177, 178

Sigmoid 激活函数 79

Sigmoid 函数 59

简单线性回归 202-204

简单存储服务 (S3) 90

单点登录 (SSO) 9

偏斜检测 120

Softmax 激活函数 80

固态硬盘 (SSD) 6

稀疏分类交叉熵 77

语音合成标记语言 (SSML) 114

语音到文本 (STT) API

关于 113, 114, 268

异步识别 114

流式识别 114

同步识别 114

步长 170

随机梯度下降 (SGD) 78

存储阵列 6

流式识别 114

监督学习 42

支持向量机 (SVM) 60, 61

支持向量 61

Symmetrix 6

同步识别 114

语法分析

操作 113

系统实体

参考链接 290

T

Tanh 激活函数 79

张量

概念 93

数据类型 (dtype) 93

排名 93-95

形状 93

TensorBoard 106, 107

TensorFlow 93

TensorFlow 扩展 (TFX) 105, 120

TensorFlow 流张量 93, 95

张量处理单元 (TPU) 96

文本检测 111

文本到语音 113, 114

tf.keras.optimizers

参考链接 78

训练流程 105

真阴性 (TN) 64

真阳性率 (TPR) 65

真阳性 (TP) 64

元组 28

U

无监督学习问题 42

加权 46

用户界面 (UI) 277

使用变量 25

V

Vertex AI

API，使能 215-218

批量预测 236-238

数据集 218-222

特征存储 243- 247

元数据 247-252

模型监控 253-258

模型训练 225-230

管道 247-252

任务，标注 222-225

工作台 239-242

Vertex AI 自动机器学习

关于 101，102

模型 102

Vertex AI 批量预测 104, 105

Vertex AI 数据标注 100

Vertex AI 数据集

关于 100

图像数据集 100

表格数据集 100

文本数据集 100

类型 100

视频数据集 100

Vertex AI 端点

关于 104，230

模型，通过端点部分部署 231-236

模型，通过模型部分部署 231

私有端点 104

公共端点 104

Vertex AI 实验 106, 107

Vertex AI 可解释人工智能 120

Vertex AI 特征存储

关于 100，119

参考链接 247

Vertex AI 元数据 105

Vertex AI 模型 103

Vertex AI 模型训练 101

Vertex AI 管道 105, 119

Vertex AI 平台 101-103

Vertex AI Workbench

关于 101

功能 239

Vertex AI Workbench 用户管理的笔记本 117

虚拟机 (VM) 5, 143

虚拟专用云 (VPC) 7

VPC 网络对等连接

在 vpc1 和 vpc2 之间创建 160-162

VPC 网络

使用 GCP 控制台创建 145，147

W

包装方法 49

![](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/bcm-ggl-cld-ml-engi/img/Packt_Logo_SuperSite_2022_Orange1.png)

Packt.com

订阅我们的在线数字图书馆，全面访问超过 7,000 本书和视频，以及领先的行业工具，帮助你规划个人发展并推进职业生涯。更多信息，请访问我们的网站。

为什么订阅？

• 使用来自 4,000 多位行业专业人士的实用电子书和视频，节省学习时间，多花时间编码

• 通过为你量身定制的技能计划提高学习效果

• 每月免费获得一本电子书或视频

• 完全可搜索，便于快速访问关键信息

• 复制粘贴、打印和收藏内容

你知道 Packt 为每本书都提供电子书版本，包括 PDF 和 ePub 文件吗？你可以在 packt.com 升级到电子书版本，并且作为印刷书客户，你有权获得电子书副本的折扣。如需了解更多详情，请联系我们 customercare@packtpub.com。

在 www.packt.com，你还可以阅读一系列免费的技术文章，注册各种免费通讯，并享受 Packt 书籍和电子书的独家折扣和优惠。

你可能也喜欢的其他书籍

如果你喜欢这本书，你可能对 Packt 的其他书籍也感兴趣：

使用 MLflow 进行大规模实用深度学习

Yong Liu

ISBN: 9781803241333

• 理解 MLOps 和深度学习生命周期开发

• 跟踪深度学习模型、代码、数据、参数和指标

• 在任何地方构建、部署和运行深度学习模型管道

• 在大规模上运行超参数优化以调整深度学习模型

• 构建生产级多步骤深度学习推理管道

• 实施可扩展的深度学习可解释性作为服务

• 部署深度学习批量推理和流式推理服务

• 从实验到生产部署实用的 NLP 解决方案

在 Kubernetes 上进行机器学习

Faisal Masood, Ross Brigoli

ISBN: 9781803241807

• 理解机器学习项目的不同阶段

• 使用开源软件在 Kubernetes 上构建机器学习平台

• 使用本书中介绍的机器学习平台实施一个完整的 ML 项目

• 提升贵公司向机器学习方向协作旅程的质量

• 发现如何作为数据工程师、ML 工程师或数据科学家使用该平台

• 了解如何将机器学习应用于解决真实商业问题

Packt 正在寻找像您这样的作者

如果您有兴趣成为 Packt 的作者，请访问 authors.packtpub.com 并今天申请。我们已与成千上万的开发者和技术专业人士合作，就像您一样，帮助他们将见解分享给全球技术社区。您可以提交一般申请，申请我们正在招募作者的特定热门话题，或者提交您自己的想法。

分享您的想法

您已经完成了成为 Google Cloud 机器学习工程师的旅程，我们非常乐意听听您的想法！如果您从亚马逊购买了这本书，请点击此处直接进入亚马逊评论页面并分享您的反馈或在该购买网站上留下评论。

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