BigQueryML-机器学习-全-

BigQueryML 机器学习（全）

原文：annas-archive.org/md5/129c41c69917f87275f2c178adc5dd48

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

机器学习（ML）的民主化是人工智能行业中增长最快的趋势之一。在这个领域，BigQuery ML 代表了连接数据分析与实施创新机器学习模型之间差距的基本工具。通过本书，您将有机会学习如何使用增量方法结合技术解释和动手练习来使用 BigQuery 和 BigQuery ML。在简短的介绍之后，您将立即能够使用 BigQuery ML 在具体用例上构建机器学习模型。到本书结束时，您将能够选择合适的机器学习算法来训练、评估和使用高级机器学习模型。

本书面向对象

本书面向数据科学家、数据分析师、数据工程师以及任何想要开始使用 Google 的 BigQuery ML 的人。如果您想加速机器学习模型的发展，或者您是一个希望以简单方式使用 SQL 应用机器学习的商业用户，本书也会很有用。需要具备基本的 BigQuery 和 SQL 知识。

本书涵盖内容

第一章, Google Cloud 和 BigQuery 简介，提供了对 Google Cloud 平台和 BigQuery 分析数据库的概述。

第二章, 设置您的 GCP 和 BigQuery 环境，解释了配置您的第一个 Google Cloud 账户、项目和 BigQuery 环境。

第三章, 介绍 BigQuery 语法，涵盖了在 BigQuery 上工作的主要 SQL 操作。

第四章, 使用线性回归预测数值，解释了开发一个线性回归机器学习模型来预测自行车租赁服务的行程时长。

第五章, 使用二元逻辑回归预测布尔值，解释了实现一个二元逻辑回归机器学习模型来预测出租车公司客户的行为的实现。

第六章, 使用多类逻辑回归对树木进行分类，解释了开发一个多类逻辑机器学习算法，根据树木的自然特征自动分类树种。

第七章, 使用 K-Means 算法进行聚类，介绍了如何实现一个聚类系统来识别出租车公司中表现最佳的司机。

第八章, 使用时间序列进行预测，概述了设计并实现一个预测工具来预测和展示特定产品的销售情况。

第九章，通过矩阵分解建议合适的产品，解释了如何使用矩阵分解算法构建推荐引擎，为每位客户推荐最佳产品。

第十章，使用 XGBoost 预测布尔值，介绍了如何实现一个提升树机器学习模型来预测出租车公司客户的行为了。

第十一章，实现深度神经网络，涵盖了设计并实现一个深度神经网络（DNN）来预测自行车租赁服务的行程时间。

第十二章，使用 AI Notebooks 与 BigQuery ML 结合使用，解释了如何将 AI Platform Notebooks 与 BigQuery ML 集成以开发和共享机器学习模型。

第十三章，使用 BigQuery ML 运行 TensorFlow 模型，解释了 BigQuery ML 和 TensorFlow 如何协同工作。

第十四章，BigQuery ML 技巧和最佳实践，涵盖了在开发 BigQuery ML 模型期间可以应用的最佳实践和技巧。

要充分利用本书

您需要具备基本的 SQL 语法知识以及一些使用数据库的经验。

对机器学习基础知识的了解不是强制性的，但建议具备。

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

下载示例代码文件

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

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

代码实战

您可以在bit.ly/3f11XbU观看本书的“代码实战”视频。

下载彩色图像

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

使用的约定

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

文本中的代码：表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 账号。以下是一个示例：“使用 ORDER BY 子句根据特定字段列表对查询结果进行排序。”

代码块设置如下：

UPDATE
    `bigqueryml-packt.03_bigquery_syntax.first_table`
SET
    description= 'This is my updated description'
WHERE
    id_key=1;

粗体：表示新术语、重要单词或屏幕上看到的单词。例如，菜单或对话框中的单词在文本中显示如下。以下是一个示例：“BigQuery 支持两种不同的 SQL 语法：标准 SQL 和 旧版 SQL。”

小贴士或重要注意事项

显示如下。

联系我们

我们欢迎读者的反馈。

客户服务@packtpub.com。

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

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

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

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

第一部分：简介和环境设置

本节介绍了机器学习，并对本书下一部分将使用的技术工具进行了概述：Google Cloud Platform、BigQuery、BigQuery ML，以及与之相关的 SQL 语法。

本节包含以下章节：

第一章, Google Cloud 和 BigQuery 简介
第二章, 设置您的 GCP 和 BigQuery 环境
第三章, 介绍 BigQuery 语法

第一章：Google Cloud 和 BigQuery 简介

公共云的采用使公司和用户能够访问创新且成本效益高的技术。这在大数据和人工智能（AI）领域尤其有价值，因为新的解决方案正在提供几年前仅凭本地系统似乎无法实现的可能性。为了在公司的日常业务中有效，新的 AI 能力需要在不同角色之间共享，而不仅仅是技术人员。目前，大多数云服务提供商都在应对将 AI 民主化到不同部门和不同技能的员工中的挑战。

在这种情况下，Google Cloud 提供了多项服务，以加速大量数据的处理并构建可以做出更好决策的机器学习（ML）应用程序。

在本章中，我们将逐步介绍在即将到来的动手活动中将非常有用的主要概念。我们将采用增量方法，探讨以下主题：

介绍 Google Cloud Platform
探索 GCP 上的 AI 和 ML 服务
介绍 BigQuery
发现 BigQuery ML
理解 BigQuery 定价

介绍 Google Cloud Platform

从 1998 年 Google Search 的推出开始，Google 开发了一个世界上最大和最强大的 IT 基础设施之一。今天，这个基础设施被数十亿用户用于使用 Gmail、YouTube、Google Photo 和 Maps 等服务。10 年后，在 2008 年，Google 决定将其网络和 IT 基础设施向商业客户开放，将最初为消费应用程序开发的架构转向公共服务，并推出了 Google Cloud Platform（GCP）。

Google 目前为大型企业和小型及中型企业提供 90 多项服务，涵盖以下类别：

计算：用于支持使用虚拟机（如 Google Compute Engine）、容器（如 Google Kubernetes Engine）或平台（如 AppEngine）的工作负载或应用程序。
存储和数据库：用于以简单方便的方式存储数据集和对象。一些示例包括 Google Cloud Storage、Cloud SQL 和 Spanner。
网络：用于通过 虚拟私有云（VPC）、防火墙和完全管理的全球路由器轻松连接全球不同位置和数据中心。
大数据：用于以结构化、半结构化或非结构化格式存储和处理大量信息。这些服务包括 Google DataProc、GCP 提供的 Hadoop 服务以及本书的主要焦点 BigQuery。
人工智能和机器学习：这个产品领域为各种用户提供各种工具，使他们能够在日常业务中利用 AI 和 ML。一些示例包括 TensorFlow、AutoML、Vision APIs 和本书的主要焦点 BigQuery ML。
身份、安全和管理工作：这个领域包括所有必要的服务，以防止未经授权的访问、确保安全和监控所有其他云基础设施。身份访问管理、密钥管理服务、云日志和云审计日志只是这些工具中的一些。
物联网（IoT）：用于将植物、车辆或任何其他对象连接到 GCP 基础设施，从而能够开发现代 IoT 应用案例。这个领域的核心组件是 Google IoT Core。
API 管理：工具，通过 REST API 向客户和合作伙伴公开服务，提供充分利用互连优势的能力。在这个支柱中，Google Apigee 是最著名的产品之一，并被认为是这个市场领域的领导者。
生产力：用于提高所有希望开始与 Google 合作并采用其商业方式的公司的工作效率和协作，通过 Google Workplace（以前称为 GSuite）强大的工具。

与 GCP 交互

所提到的所有服务都可以通过四个不同的接口访问：

Google Cloud Console：GCP 的基于网页的用户界面，可以通过兼容的网页浏览器（如 Google Chrome、Edge 或 Firefox）轻松访问。在本书的手动练习中，我们将主要使用 Google Cloud Console：

![图 1.1 – Google Cloud Console 截图

![img/B16772_01_001.jpg]

图 1.1 – Google Cloud Console 截图

Google Cloud SDK：可以通过安装客户端 SDK 来与 GCP 服务通过命令行交互。通过将这些任务和操作安排到脚本中，可以非常方便地自动化任务和操作。
客户端库：SDK 还包括一些客户端库，用于使用最常用的编程语言（如 Python、Java 和 Node.js）与 GCP 交互。
REST API：在 GCP 上执行的所有任务或操作都可以通过从任何兼容软件调用特定的 REST API 来执行。

现在我们已经学会了如何与 GCP 交互，让我们来看看 GCP 与其他云服务提供商有何不同。

发现 GCP 的关键差异化特点

GCP 不是市场上唯一的公共云服务提供商。其他公司也开始了这种业务，例如，与 Amazon Web Services（AWS）、Microsoft Azure、IBM 和 Oracle。因此，在我们深入本书内容之前，了解 GCP 与云市场中的其他提供有何不同可能很有价值。

每个云服务提供商都有自己的使命、战略、历史和优势。让我们看看为什么 Google Cloud 可以被认为与其他所有云服务提供商不同。

安全

Google 为其全球数据中心提供端到端的安全模型，使用由 Google 开发和使用的定制硬件，默认启用应用程序加密。Google 为 GCP 采用的安全最佳实践与用于运行拥有超过 10 亿用户的应用程序（如 Gmail 和 Google Maps）开发的相同。

全球网络和基础设施

在撰写本文时，Google 的基础设施在全球 24 个不同地区、74 个可用区域和 144 个网络边缘位置可用，使客户能够连接到 Google 的网络，并确保在带宽、网络延迟和安全方面提供最佳体验。此网络允许 GCP 用户在不同地区之间移动数据，而无需离开 Google 的专有网络，从而最大限度地降低在公共互联网上发送信息的风险。截至目前，估计大约 40% 的互联网流量通过 Google 的专有网络。

在以下图中，我们可以看到 GCP 区域在全球的分布情况：

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/ml-bgqlml/img/B16772_01_002.jpg)

图 1.2 – Google 全球可用性地图

最新版本的地图可以在以下网址查看：cloud.google.com/about/locations。

无服务器和完全托管方法

Google 提供了许多完全托管和无服务器服务，以使客户能够专注于高价值活动，而不是维护操作。一个很好的例子是将在本章下一节介绍的 BigQuery，一个无服务器数据仓库。

环境可持续性

Google 数据中心使用的 100% 能源来自可再生能源。此外，Google 承诺到 2030 年成为第一家对所有运营（如数据中心和园区）实现无碳化的主要公司。

普及人工智能

Google 是人工智能行业的先驱，正在利用人工智能和机器学习来改进其消费产品，例如 Google Photos，同时也用于提高其数据中心性能和效率。所有关于人工智能和机器学习的 Google 专业知识都可以通过采用 GCP 服务，如 AutoML 和 BigQuery ML，由客户利用。这将是本书的主要内容。

既然我们已经讨论了 GCP 作为服务的一些关键要素，让我们更具体地看看人工智能和机器学习。

探索 GCP 上的 AI 和 ML 服务

在我们深入探讨 GCP 的所有 AI 和 ML 工具之前，记住 Google 是一家 AI 公司，并在其许多其他产品中嵌入 AI 和 ML 功能，为顾客提供最佳的用户体验，这一点非常重要。仅仅看看 Google 的产品，我们就可以很容易地感知到 AI 可以成为企业的关键资产。以下是一些例子：

Gmail 智能回复允许用户快速回复电子邮件，根据对话的上下文提供有意义的建议。
Google Maps 能够通过结合不同的数据源，精确预测我们从一地移动到另一地的时间。
Google Translate 为超过一百种语言提供翻译服务。
YouTube 和 Google Play Store 能够根据用户偏好推荐最佳观看视频或最有用的移动应用程序。
Google Photos 能够识别我们照片中的人、动物和地点，简化了归档和组织我们照片的工作。

Google 证明了利用人工智能和机器学习能力在我们的业务中开辟了新的机遇，增加了我们的收入，节省了金钱和时间，并为我们的客户提供了更好的体验。

为了更好地理解 GCP 在人工智能和机器学习服务方面的丰富性，重要的是强调 GCP 服务能够解决机器学习模型典型生命周期中出现的所有需求：

数据集的摄取和准备
模型的构建和训练
评估和验证
部署
模型的维护和进一步改进

在以下图中，您可以查看整个 AI 和机器学习 GCP 产品组合：

![图 1.3 – 以其图标表示的 GCP 人工智能和机器学习服务

![img/B16772_01_003.jpg]

图 1.3 – 以其图标表示的 GCP 人工智能和机器学习服务

每一个之前提到的五个阶段都可以完全由用户管理或委托给 GCP 的自动化能力，根据客户的需求和技能。因此，可以将 GCP 提供的人工智能和机器学习服务分为三个子类别：

核心平台服务
人工智能应用
解决方案

对于这些子类别中的每一个，我们将介绍目前最重要的服务以及可能从中受益的一些典型用户。

核心平台服务

核心人工智能和机器学习服务是客户可以在 GCP 上使用的最细粒度项目，以开发人工智能和机器学习用例。它们为用户提供最大的控制和灵活性，以换取较少的自动化；用户还需要在机器学习方面拥有更多的专业知识。

处理单元（CPU、GPU 和 TPU）

使用传统的基础设施即服务（IaaS）方法，开发者可以为他们的 Google Compute Engine 实例配备强大的处理单元，以加速可能需要很长时间运行的机器学习模型的训练阶段，尤其是当需要处理复杂上下文或大量数据时。除了我们笔记本电脑上可用的中央处理器（CPUs）之外，GCP 还提供了由 Nvidia 制造的高性能图形处理器（GPUs）的使用，这些处理器可在云端使用以加快计算密集型任务的执行。除此之外，还有张量处理单元（TPUs），它们专门设计用于支持机器学习工作负载并执行矩阵计算。

深度学习 VM 镜像

对于数据科学家来说，最大的挑战之一是快速配置环境以开发他们的 ML 模型。因此，Google Cloud 提供了预配置的 Google Compute Engine（GCE）映像，可以轻松配置预构建的组件和库集，这些组件和库集专门用于 ML。

在以下屏幕截图中，您可以查看这些 虚拟机（VM）在 GCP 市场中的展示方式：

图 1.4 – GCP 市场中的深度学习 VM

深度学习 VM 映像也针对 ML 工作负载进行了优化，并且已经预先配置以使用 GPU。当从 GCP 市场中配置 GCE 映像时，它已经配置了最常用的 ML 框架和编程语言，例如 Python、TensorFlow、scikit-learn 等。这使得数据科学家能够专注于模型开发，而不是开发环境的配置和供应。

TensorFlow

TensorFlow 是一个开源的数学、统计学和 ML 框架。它由 Google Brain 为 Google 内部使用而推出，后来在 Apache License 2.0 下发布。它仍然是大多数成功 Google 产品的核心。该框架原生支持 Python，但也可以与其他编程语言（如 Java、C++ 和 Go）一起使用。它需要 ML 专业知识，但允许用户在定制和灵活性方面取得很好的成果，以开发最佳的 ML 模型。

AI 平台

AI 平台是 GCP 的一个集成服务，它提供无服务器工具来训练、评估、部署和维护 ML 模型。使用此服务，数据科学家可以只关注他们的代码，简化所有 ML 开发的辅助活动，如供应、维护和可扩展性。

AI 平台 Notebooks

AI 平台 Notebooks 是一个完全托管的服务，为数据科学家提供了一个已经集成并连接到所有其他 GCP 资源的 JupyterLab 环境。类似于深度学习 VM 映像，AI 平台 Notebooks 实例预先配置了最新的 AI 和 ML 框架版本，允许您使用图表和书面说明来开发 ML 模型。

到目前为止所描述的所有服务都需要对 ML 有良好的了解，并且在最常用的编程语言中手动编码的实践经验。核心平台服务满足数据科学家和需要对其构建的解决方案有完全控制和灵活性的 ML 工程师的需求，他们已经拥有强大的技术技能。

构建模块

在核心平台服务之上，Google Cloud 提供了预构建的组件，可用于加速新 ML 用例的开发。这一类别包括以下方面：

AutoML

与上一节中概述的服务不同，AutoML提供了即使在有限领域专业知识的情况下也能构建机器学习模型的能力。它利用 Google 的机器学习能力，并允许用户提供数据以训练 Google 已开发的算法的定制版本。AutoML 目前提供训练图像（AutoML Vision）、视频（AutoML Video Intelligence）、自由文本（AutoML Natural Language）、翻译（AutoML Translation）和结构化数据（AutoML Tables）模型的能力。当机器学习模型训练完成并准备好使用时，它将自动部署并通过 REST 端点提供。

预构建 API

Google Cloud 提供了预构建 API，这些 API 在底层利用机器学习技术，但已经过训练并准备好使用。API 通过标准 REST 接口公开，可以轻松集成到应用程序中，用于处理图像（Vision API）、视频（Video API）、自由文本（Natural Language API）、翻译（Translation API）、电子商务数据（Recommendations AI）和对话场景（Speech-to-Text API、Text-to-Speech API和Dialogflow）。使用预构建的机器学习 API 是通用应用程序的最佳选择，其中可以使用通用训练数据集。

BigQuery ML

如本章后续部分将详细讨论BigQuery ML，目前你只需知道这个组件允许用户使用 SQL 语言，利用存储在 BigQuery 中的结构化数据和一系列支持的算法来构建机器学习模型。

这里描述的任何构建块都不需要任何特定的机器学习知识或任何编程语言的证明编码经验。实际上，这些服务是为那些不太熟悉机器学习但希望快速且轻松地开始使用的开发人员或业务分析师而设计的。另一方面，具有机器学习专业知识的科学家也可以利用构建块来加速模型开发，从而缩短解决方案的上市时间。

要查看构建块的摘要、用法和目标用户，让我们看看以下表格：

![图 1.5 – 构建块摘要表

![图片 B16772_01_005.jpg]

图 1.5 – 构建块摘要表

现在我们已经学习了构建块的基础知识，让我们来看看 GCP 提供的解决方案。

解决方案

按照增量方法，构建块和核心平台服务也捆绑在一起，以提供即插即用的解决方案。这些预构建模块可以被公司采用并立即用于改善他们的业务。这些解决方案在本节中介绍。

AI Hub

Google Cloud 的AI Hub充当 AI 组件的市场。它可以以公共模式使用，以共享和使用社区开发并由 GCP 积极工作的资产，或者它可以以私有模式使用，以在您的公司内部共享 ML 资产。此服务的目标是简化不同用户之间有价值资产的共享，促进重用并加速新用例的部署。

在下面的屏幕截图中，您可以查看 AI Hub 的主页：

![Figure 1.6 – Screenshot of AI Hub on GCP]

![img/B16772_01_006.jpg]

图 1.6 – GCP 上 AI Hub 的屏幕截图

现在我们已经了解了 AI Hub 的作用，让我们来看看 Cloud Talent Solution。

Cloud Talent Solution

Cloud Talent Solution 基本上是一个针对人力资源办公室的解决方案，利用 AI 改进候选人发现和招聘流程。我们不会进一步描述此解决方案，但将在本章末尾的进一步资源部分提供链接。

接触中心 AI

接触中心 AI是一种解决方案，可用于通过由 AI 和自动化驱动的接触中心来提高客户体验的有效性。该解决方案基于 Dialogflow 以及文本到语音和语音到文本 API。

文档 AI

此解决方案专注于文档处理，以提取相关信息并简化通常需要人工努力的业务流程。该解决方案能够解析 PDF 文件、图像和手写文本，将这些信息转换为数字化结构格式，使其可访问并可进行研究。

从它们的描述中可以轻易看出，Google 提供的 AI 解决方案更偏向于商业导向，旨在解决特定的挑战。它们可以配置和定制，但基本上是针对商业用户的。

在继续之前，让我们看一下以下表格，该表格总结了本节中解释的概念，并提供了不同 AI 和 ML 服务类别的清晰概述：

![Figure 1.7 – Summary of GCP AI and ML services]

![img/B16772_01_007.jpg]

图 1.7 – GCP AI 和 ML 服务的概述

小贴士

当您需要开发新的用例时，我们建议在尝试重新发明轮子之前，先使用预构建的解决方案和构建块。如果一个构建块已经满足您用例的所有要求，那么使用它将非常有价值。它将在开发和维护阶段节省时间和精力。只有在用例复杂或非常特别，无法使用构建块或解决方案解决的情况下，才开始考虑使用核心服务。

正如我们在本节中看到的，GCP 的 AI 和 ML 服务非常广泛。现在，让我们更深入地探讨本书的主要主题：Google BigQuery。

介绍 BigQuery

Google BigQuery 是谷歌在 2006 年内部构建的高度可扩展、无服务器、分布式数据仓库技术，并于 2010 年在 GCP 上公开发布。由于其架构，它能够存储 PB 级的数据，并以高性能和按需扩展查询它们。由于其无服务器特性，存储和查询数据的 BigQuery 用户无需管理底层基础设施，可以专注于实现带来商业价值的逻辑，节省时间和资源。

BigQuery 目前被许多大型企业使用，它们利用它来做出数据驱动的决策，包括 Twitter、家得宝和道琼斯。

BigQuery 架构

BigQuery 具有分布式架构，在谷歌数据中心成千上万的节点上运行。您的数据集不是存储在单个服务器上，而是被分块并在不同地区复制，以确保最大性能和可用性。

在 BigQuery 中，存储层和计算层是完全解耦的。这意味着查询引擎在存储数据的服务器之外的其他服务器上运行。这一特性使 BigQuery 能够在数据量和查询执行方面提供出色的可扩展性。这种解耦范式仅得益于谷歌的 Petabit 网络，它利用谷歌在全球范围内专有的光纤电缆，将数据快速从一个服务器移动到另一个服务器。

现在让我们更深入地了解 BigQuery 如何管理存储和计算引擎。

存储层

与传统的数据仓库不同，BigQuery 以列格式而不是行格式存储数据。这种方法使您能够执行以下操作：

实现每个列的更好压缩率，因为列中的数据通常是同质的，更容易压缩。
减少读取的数据量，以获得数据仓库用例的最佳性能，这些用例通常基于表中的一小部分列和聚合操作，如总和、平均值和最大值。

所有数据都存储在谷歌的专有分布式文件系统 Google 文件系统（代号科洛苏斯）中。数据的分布允许它在发生故障的情况下保证更快的 I/O 性能和更好的数据可用性。Google 文件系统基于两种不同的服务器类型：

主服务器：不存储数据但负责管理每个文件元数据的节点，例如组成文件的每个数据块的位置和可用副本数量。
数据块服务器：实际存储跨不同服务器复制的文件数据块的节点。

在以下图中，您可以了解 Google 文件系统如何管理数据：

![图 1.8 – Google 文件系统（科洛苏斯）存储策略

![img/B16772_01_008.jpg]

图 1.8 – Google 文件系统（科洛苏斯）存储策略

现在我们已经了解了 BigQuery 如何处理大量数据，让我们看看计算层如何访问这些数据。

计算层（查询层）

完全与存储解耦，计算层负责接收来自 BigQuery 用户的查询语句并以最快的方式执行它们。查询引擎基于 Dremel 技术，该技术由谷歌开发并于 2010 年发表在论文中。该引擎利用多级树架构：

树的根节点接收要执行的查询。
根节点将查询分割并分配给其他名为混合器的中间节点。
混合节点负责在将查询传递给叶节点或其他中间混合节点之前重写查询。
叶节点负责从 Google 文件系统中并行读取数据块。
当从文件系统中提取出正确的数据块时，叶节点会对数据进行计算，并最终将它们在其他的叶节点之间进行洗牌。
计算结束时，每个叶节点生成一个结果，并将其返回给父节点。
当所有结果返回到根节点时，查询的结果将被发送给请求执行的用户或应用程序。

基于 multi-level tree 的 BigQuery 查询执行过程在以下图中表示：

图 1.9 – BigQuery 引擎是一个多级树

每个节点提供多个处理单元，称为 BigQuery 插槽，以执行查询的业务逻辑。一个 BigQuery 插槽可以被视为 Dremel 节点上的虚拟 CPU。所需插槽的计算以执行特定查询的复杂性和受影响的数据量自动由 BigQuery 管理。

BigQuery 相比传统数据仓库的优势

现在我们已经了解了 BigQuery 之下的技术架构，让我们看看这种架构如何转化为使用它的企业相对于其他传统本地数据仓库成为数据驱动型公司的优势。

无服务器

正如我们提到的，BigQuery 具有无服务器架构，这使用户免于管理服务器配置和维护，以及与操作系统升级和修补相关的所有维护操作，这些操作支持数据仓库的运行。得益于无服务器方法，用户可以轻松地将数据导入 BigQuery 并使用它，而无需进行容量规划或预先进行任何硬件和软件配置。这对于原型设计和实现快速失败的方法尤为重要，这种方法有利于创新和实验的文化。

可扩展性

无论您需要存储兆字节的数据还是拍字节的数据；BigQuery 都能在数据存储和处理方面为您提供最大的灵活性和可扩展性。得益于其多租户架构，小型或中型企业可以像最大型企业一样利用相同的创新功能，或者他们可以从一个小用例开始，根据业务需求进行扩展。传统的数据仓库技术使用相同的服务器进行存储和计算。因此，它们对于不平衡的用例（例如，需要大量数据存储但不需要高性能计算，或者相反）并不特别适合。得益于其解耦架构，正如我们在上一节中看到的，BigQuery 被设计为根据用户的实际需求独立扩展存储和计算能力，从而降低解决方案的总拥有成本。

可用性

多亏了其弹性、分布式架构，BigQuery 能够提供每月可用性百分比超过 99.99% 的 服务级别协议 (SLA)。这种非常高的可用性标准是由 Google 无需 BigQuery 用户额外努力就授予的，用户无需关心高可用性或灾难恢复策略。

性能

BigQuery 引擎能够在几秒钟内查询千兆字节的数据，在几分钟内查询拍字节的数据。这种性能是使用传统的本地数据仓库很难实现的。更高的性能意味着可以更快地获得洞察力，以及处理大量数据，这些数据通常在没有大量硬件和软件投资的情况下，在本地是无法管理的。为了进一步提高性能，BigQuery 提供了启用 BigQuery BI Engine 的可能性。BigQuery BI Engine 是一个内存分析层，可以在 BigQuery 上激活以更快地执行查询，具有亚秒级延迟。

实时性

传统的数据仓库是为长时间批量操作设计的，通常无法管理实时工作负载。然而，BigQuery 提供了一个特定的接口来实时摄取数据，使其立即可用于分析。这一特性为希望加速其分析并克服数据仓库典型方法的公司开辟了新的可能性，数据仓库通常涉及处理前一天的业务情况。

格式灵活性

BigQuery 在 Google 文件系统中以压缩和优化的格式存储文件，但提供了以数据湖技术中通常使用的各种格式加载数据的选项。用户可以使用 Avro、ORC、CSV 和 JSON 格式将数据加载到 BigQuery 中。

创新功能

BigQuery 提供了两种在传统数据仓库中不可用的 SQL 扩展：

BigQuery GIS：通过 SQL 语句执行地理计算和操作，能够轻松管理地理空间数据
BigQuery ML：允许用户利用 SQL 语言训练、评估和运行 ML 模型，无需编程经验，加速创新用例的开发

安全性

默认情况下，BigQuery 在将客户数据存储在 Google 文件系统之前自动加密和解密数据。BigQuery 还负责管理和轮换加密和解密密钥。为了进一步提高安全性，BigQuery 提供了使用 客户管理加密密钥（CMEKs）的选项。在这种情况下，密钥由客户直接在 Google Cloud Key Management System 中管理。

通过设置 Google 身份访问管理系统（IAM）中的正确角色，可以防止未授权的数据访问和使用。

与其他 GCP 服务的集成

使用 BigQuery 的一个巨大好处是与许多其他 GCP 服务本地的集成：

![图 1.10 – BigQuery 与其他 GCP 服务的集成]

![img/B16772_01_010.jpg]

图 1.10 – BigQuery 与其他 GCP 服务的集成

正如我们在前面的屏幕截图中可以看到的，Google BigQuery 可以使用外部表从 Google Bigtable、Google Cloud Storage、Google Cloud SQL 和 Google Drive 读取数据。这个功能可以简化从其他数据库到 BigQuery 的数据导入，这也可以使用 ETL/ELT 工具如 Google Dataflow 和 Data Fusion 来执行。当数据集存储在 BigQuery 中时，它们可以从其他 GCP 组件访问，例如用于数据处理和准备的 Google DataProc、DataPrep，用于数据可视化的 Data Studio、Looker 和 Google Sheets。BigQuery 与 AI Platform Notebooks 集成，允许数据科学家和工程师轻松地从他们的 Jupyter 环境访问数据。

总结来说，将数据引入 BigQuery 打开了大量可供用户根据需要使用的选项。

丰富的合作伙伴生态系统

除了与其他 GCP 服务的集成之外，Google 的合作伙伴还提供了与 BigQuery 的连接器和集成，从而创建了一个丰富的数据管理生态系统。一些例子包括 Informatica、Tableau、Fivetran、Talend 和 Confluent。

公共数据集

如果你想从头开始使用 BigQuery，你可以利用来自 BigQuery 公共数据集计划的现有公共表。该计划包含来自不同行业和不同国家关于不同主题的有趣数据集。我们将在下一章中使用的一些示例包括来自共享单车服务的交易、纽约市的开放数据和出租车行程记录。

与 BigQuery 交互

与 BigQuery 交互有不同的方式。它们是：

Google Cloud Console 中的 BigQuery 网页界面，可通过网络浏览器访问的图形用户界面，是交互 BigQuery 的最简单方式。
bq 命令行，在安装 Google Cloud SDK 时可用。它可以通过将它们包含在脚本中来自动化作业和命令。
BigQuery REST API。BigQuery 本地提供的 API 层可以用来将此服务与其他应用程序集成。
客户端库，以促进最常用编程语言的使用，例如 C#、Go、Java、Node.js、PHP、Python 和 Ruby。
由 Google 合作伙伴 Magnitude Simba Driver 开发的 JDBC/ODBC 驱动程序适用于 Windows、macOS 和 Linux 系统。
第三方和 Google 的合作伙伴为他们的应用程序开发了 BigQuery 连接器，例如 Tableau 用于商业智能，Informatica 和 Talend 用于数据摄取和集成。

对于我们的目的，我们将查看 Google Cloud Console 中可用的 BigQuery 网页 UI，它将在接下来的章节中用于使用 BigQuery ML 进行开发。

在下面的屏幕截图中，您可以看到 BigQuery UI 在 GCP 控制台中的外观：

![图 1.11 – GCP 控制台中可用的 BigQuery 网页和图形用户界面]

![图片 B16772_01_011.jpg]

![图 1.11 – GCP 控制台中可用的 BigQuery 网页和图形用户界面]

在左侧列中，可用的主要 BigQuery 功能以及数据集被列出并可供用户查看。在这种情况下，只有一个数据集。

屏幕的其余部分被开发画布占据，底部显示结果和输出。我们将在 第二章，“设置您的 GCP 和 BigQuery 环境”中学习如何使用 BigQuery 网页 UI，届时我们将创建 GCP 项目并开始使用 BigQuery。

BigQuery 数据结构

BigQuery 结构，如表、视图和 ML 模型，组织在数据集中。每个数据集都是一个不同结构的容器，可以用来控制对底层数据结构的访问。数据集直接链接到以下内容：

托管数据集本身的 GCP 项目，通常与存储费用计费相关的计费账户相关联
在创建时定义的地理位置（区域或多区域），以后不能更改
分配给数据集的特定名称，应在 GCP 项目中是唯一的

在以下图中，您可以看到由项目、数据集、表和 BigQuery ML 模型组成的层次结构示例：

![图 1.12 – BigQuery 层次结构：数据集、表、视图和 ML 模型]

![图片 B16772_01_012.jpg]

![图 1.12 – BigQuery 层次结构：数据集、表、视图和 ML 模型]

在 GCP 上托管的数据集，项目 A，如果设置了正确的权限，也可以被链接到另一个 GCP 项目，项目 B 的用户查询。在这种情况下，存储费用将计费给托管数据集结构的 项目 A，而计算费用则计费给与 项目 B 相关的计费账户。这正是我们在未来章节中使用 BigQuery 公共数据集进行动手练习时会发生的情况。

小贴士

记住，你的查询只能包括位于同一区域的表。在 BigQuery 中，你不能查询存储在不同地理位置的表。如果你想在位于不同区域的表中执行查询，你需要将数据导出并导入到同一区域的数据集中，通过 Google Cloud Storage 进行。

现在我们已经了解了 BigQuery 的主要特性，让我们更具体地关注这本书的核心：BigQuery ML。

发现 BigQuery ML

开发一个新的机器学习模型可能需要大量的努力，可能是一项耗时的工作。它通常需要不同的技能，是一项复杂的活动，尤其是在大型企业中。机器学习模型的典型旅程可以用以下流程来概括：

![图 1.13 – 机器学习模型的典型开发生命周期

![img/B16772_01_013.jpg]

图 1.13 – 机器学习模型的典型开发生命周期

前两个步骤涉及初步的原始数据分析操作：

在数据探索和理解阶段，数据工程师或数据科学家首先查看数据，试图理解数据集中所有列的含义，然后选择考虑的新用例中的字段。
在数据准备阶段，数据工程师对数据集进行筛选、聚合和清理，使其可用于后续的训练阶段。

在这两个初步阶段之后，实际的机器学习开发过程开始：

利用 TensorFlow 等机器学习框架和 Python 等编程语言，数据科学家将参与设计机器学习模型步骤，在训练数据集上尝试不同的算法。
当选择了正确的机器学习算法后，数据科学家会执行机器学习模型的调优步骤，应用特征工程技术和超参数调优以获得更好的模型性能。
当模型准备就绪时，在评估数据集上执行最终的评估步骤。这一阶段证明了机器学习模型在不同于训练数据集的新数据集上的有效性，并最终导致对资产的进一步优化。
在开发过程之后，机器学习模型通常会在具有可扩展性和健壮性要求的生产环境中部署和使用。
由于不同的输入数据或为了应用进一步的改进，机器学习模型最终也会在后续阶段进行更新。

所有这些步骤都需要不同的技能，并且基于不同利益相关者的协作，例如，数据分析师进行数据探索和理解，数据工程师进行数据准备，数据科学家进行机器学习模型的开发，最后是 IT 部门确保模型在安全、健壮和可扩展的生产环境中可用。

BigQuery ML 简化并加速了新机器学习模型整个开发过程，允许你执行以下操作：

设计、训练、评估和部署机器学习模型，利用 SQL 和公司现有的技能。
自动化大多数通常耗时很高的调优活动，以获得有效的模型。
确保您拥有一个强大、可扩展且易于使用的机器学习模型，利用我们已在本章“BigQuery 相对于传统数据仓库的优势”部分讨论的所有 BigQuery 原生功能。

在以下图中，您可以查看使用 BigQuery ML 的机器学习模型的生命周期：

图 1.14 – 使用 BigQuery ML 的机器学习模型开发生命周期

现在我们已经学习了 BigQuery ML 的基础知识，让我们来看看它可以带来的主要好处。

BigQuery ML 优势

BigQuery ML 可以在机器学习模型的生命周期中带来商业和技术效益：

商业用户和数据分析师可以从传统的描述性和报告方法演变到新的预测方法，利用他们现有的 SQL 技能做出更好的决策。
技术用户可以在模型的调优阶段从 BigQuery ML 的自动化中受益，使用一个独特、集中的工具，可以加速整个机器学习模型开发过程。
由于构建机器学习模型所需的数据集已经对正确用户可用，无需从一个数据存储库移动到另一个数据存储库，这降低了合规性和数据重复的风险，因此开发过程进一步加快。
IT 部门无需管理基础设施以在生产环境中管理和使用机器学习模型，因为 BigQuery 的无服务器架构原生支持以可扩展、安全、稳健的方式支持模型。

在我们分析了 BigQuery ML 可以带来的好处之后，现在让我们看看支持的机器学习算法有哪些。

BigQuery ML 算法

BigQuery ML 支持的机器学习算法列表正在迅速增长。目前，以下监督式机器学习技术目前得到支持：

线性回归：使用线性模型预测数值
二元逻辑回归：适用于在只有两种不同选项之间进行选择的分类用例（是或否、1 或 0、真或假）
多类逻辑回归：适用于在多个选项之间进行选择的分类场景
矩阵分解：基于历史信息开发推荐引擎
时间序列：利用过去的时间序列数据预测业务 KPI
提升树：适用于具有 XGBoost 的分类和回归用例
AutoML 表：从 BigQuery SQL 界面利用 AutoML 功能
深度神经网络（DNN）：用于开发分类或回归场景的 TensorFlow 模型，避免任何代码行

当训练数据集不包含标记数据时，学习被定义为无监督学习。BigQuery ML 目前支持以下内容：

K-means 聚类：用于相似对象的（人、事实、事件）数据分割

除了列出的内容外，BigQuery ML 还允许您使用 SQL 语句导入和使用预训练的 TensorFlow 模型。

理解 BigQuery 定价

在本节中，解释了 BigQuery 和 BigQuery ML 的定价模型。由于 GCP 服务的定价不断演变，我们建议您咨询cloud.google.com/bigquery/pricing以获取最新更新。

让我们来看看 BigQuery 的模型。

BigQuery 定价

BigQuery 定价根据该技术的使用情况进行扩展。有三个主要成本驱动因素：

存储：根据存储在 BigQuery 中的数据量计算的价格。
计算资源：用于查询、转换和处理数据或训练、评估和使用机器学习模型所使用的资源。
流式传输：根据通过 BigQuery 流式传输 API 摄取的记录数计算的价格。

存储

BigQuery 存储成本是根据您的数据集未压缩的大小计算的。BigQuery 提供两层存储：

活跃：在过去 90 天内插入或更新的表中的所有数据都被视为活跃数据。截至撰写本文时，活跃存储的收费为每月每太字节 20.00 美元。
长期：在过去 90 天内未修改的表中的所有数据都被视为长期存储。截至撰写本文时，长期存储的收费为每月每太字节 10.00 美元。Google 会自动应用长期存储的更改，无需 BigQuery 用户采取任何行动。

小贴士

多亏了 BigQuery 长期存储，不再需要将归档数据传输到 Google Cloud Storage 以节省费用。您可以在非常低的成本下保持数据在线并可供访问。

计算资源

BigQuery 计算成本是根据执行查询处理的数据量计算的。计算成本可能根据客户选择的模型而变化：

按需：这是默认选项。在这种情况下，用户只需为实际使用的资源付费。
固定费率：希望对 BigQuery 成本有精确估计并希望保持其稳定性的用户或公司可以启用此选项。在这种情况下，需要为特定时间段进行预留，并将固定数量的 BigQuery 插槽分配给一个或多个 GCP 项目。截至 2020 年 10 月，可以预留的最小插槽数量为 100，最小承诺时间为 60 秒。目前，Google 允许您根据实际需求选择不同的固定费率选项。此选项可以通过月度、年度或灵活承诺启用。灵活选项允许您购买 BigQuery 插槽的短期（至少 60 秒）。

小贴士

请记住，您不需要为存储 BigQuery 公共数据集付费：您只需为访问和查询它们付费。因此，使用 BigQuery 公共数据集可以是一种成本效益的方式，在 BigQuery 上进行测试时，只需支付计算费用，而不支付存储费用。

流式传输

将数据加载到 BigQuery 中通常是免费的，除了通过 BigQuery 流式 API 发生的摄取过程。截至 2020 年 10 月，您将为此接口每 200 MB 被摄取的数据支付 0.010 美元。每一行被视为至少 1 KB。

小贴士

如果您的用例不需要实时摄取数据，我们建议您使用批量加载机制将数据摄取到 BigQuery 中，这通常是免费的。

BigQuery ML 定价

BigQuery ML 的定价模型与 BigQuery 计算成本类似。正如我们在上一节中看到的，客户可以在以下选项之间进行选择：

按需（按使用付费）定价模型
固定费率定价模型

如果客户已经选择激活具有固定数量 BigQuery 插槽的固定费率模式，BigQuery 插槽也将用于训练、评估和运行 BigQuery ML 模型。

如果客户使用按需定价模型，有必要将 BigQuery ML 算法分为两个不同的类别：

外部模型：此类包括提升树、深度神经网络（DNN）、TensorFlow 和 AutoML。这些模型在其他与 BigQuery 集成的 GCP 服务上训练，并按不同的方式收费。
内部模型：此类包括之前提到的所有直接在 BigQuery 上训练的算法。

在撰写本文时，内部模型的定价基于 ML 生命周期主要阶段（训练、评估和预测）处理的数据量：

图 1.15 – BigQuery ML 对内部 ML 模型的定价

外部模型的定价基于用于模型训练的外部 AI 平台资源的成本，以及额外应用于其上的 BigQuery ML 费用：

图 1.16 – BigQuery ML 对外部 ML 模型的定价

价格始终在审查中，并可能在 GCP 上发生变化。因此，我们建议您查阅 cloud.google.com/bigquery-ml/pricing。

免费操作和免费层

BigQuery 提供了各种免费操作，以及免费层，以免费尝试这项技术。

以下操作在 BigQuery 中始终免费：

加载数据
复制数据（除了为复制请求的额外存储空间）
导出数据
删除数据集、表、视图、分区或函数
任何元数据操作
读取元数据表和列
创建或替换用户定义函数（UDFs）

为了鼓励用户在 BigQuery 上进行实验，每个月用户都有能力利用一定阈值以下的免费操作预算，如下表所示：

图 1.17 – BigQuery ML 免费层

现在我们已经看到了我们可以使用的 BigQuery 免费层，让我们来看看价格计算器。

价格计算器

如果您想对使用按需定价的 BigQuery 的成本进行良好估算，您可以使用 Google Cloud 价格计算器：cloud.google.com/products/calculator。以下截图显示了存储、通过流式传输摄取和处理以下数据量的月度成本：

未压缩存储容量：10 TB
流式插入量：1 GB
查询处理的数据：150 TB：

图 1.18 – BigQuery 价格计算器

您可以使用价格计算器来估算所有其他 GCP 服务的消耗，以更好地了解您的 GCP 成本。

摘要

在本章的第一部分，我们迈出了学习 GCP 提供的内容、与其他公共云提供商的不同之处以及谷歌如何利用其无处不在的应用程序（如 Gmail 和 Google Maps）通过 GCP 为公司提供优质服务的第一步。

我们还发现，谷歌在 AI 和 ML 方面的丰富经验，通过制作如 Google Photos 等产品而发展起来，也构成了 GCP 服务的一部分。每个 AI 和 ML 服务都可以根据其技能和背景解决各种用例和不同类型的用户。例如，大多数技术用户，如数据科学家，可以利用 TensorFlow 在其开发的 ML 模型上获得极大的灵活性和控制力，而商业用户可以使用谷歌的解决方案通过文档 AI 和客服 AI 解决特定的挑战。中间类别由 AI 和 ML 构建块组成；这些服务可以加速新 ML 用例的开发或通过公司推广创新技术的使用。

这些构建块之一是 BigQuery：其扩展 BigQueryML 通过利用现有的 SQL 技能来开发机器学习模型。BigQuery ML 的使用可以为希望民主化机器学习的公司带来巨大利益，通过简化通常需要不同利益相关者、技能和工具参与的繁重且耗时的工作，使大量员工能够参与其中。

在下一章中，我们将通过创建一个新的谷歌云项目并首次访问 BigQuery 来进行实际操作。

进一步资源

谷歌云产品: cloud.google.com/products/
GCP 概述: cloud.google.com/docs/overview
为什么谷歌云平台与众不同: cloud.google.com/free/docs/what-makes-google-cloud-platform-different
谷歌地区和位置: cloud.google.com/about/locations
谷歌的可持续发展计划: sustainability.google/commitments/
AI Hub: aihub.cloud.google.com/?hl=en
云人才解决方案: cloud.google.com/solutions/talent-solution?hl=en
BigQuery 技术架构:cloud.google.com/files/BigQueryTechnicalWP.pdf
BigQuery 接口: cloud.google.com/bigquery/docs/interacting-with-bigquery
BigQuery ML: cloud.google.com/bigquery-ml/docs

第二章：设置您的 GCP 和 BigQuery 环境

使用新的公共云提供商的第一步可能很复杂，有时您可能会被面前所有的服务和选项所压倒。云服务提供商提供各种组件和资源来解决不同的用例。有了这么多模块，决定使用哪个服务并不容易。幸运的是，为了创建和运行一个 Google Cloud Platform (GCP) 项目，您不需要具备特定的技术技能或大量的预算来投资。无论您是私人用户还是大公司的员工，GCP 都提供了通过在平台上创建账户和项目来使用其云服务的机会。还可以利用免费试用来获取信用并测试产品一段时间。

本章涵盖的主题将帮助您为您的技术环境建立一个坚实的基础，并且所涵盖的任务应该只执行一次。为了避免任何不确定性和迷失方向，在本章中，您将逐步通过以下活动：

创建您的 GCP 账户和项目
激活 BigQuery
发现 BigQuery 网页用户界面
探索 BigQuery 公共数据集

技术要求

本章要求您能够访问网页浏览器。为了执行本章中描述的步骤，我们建议使用以下之一：

Google Chrome
Firefox
Microsoft Edge
Microsoft Internet Explorer 11+
Safari 8+（不支持 Safari 私密浏览模式）

现在您已经准备好了一个受支持的网页浏览器，让我们深入了解创建新的 GCP 账户和项目。

创建您的 GCP 账户和项目

开始使用 GCP 的第一步是创建一个新的 GCP 账户 和一个新的项目。项目是多个 GCP 资源的一个容器，通常用户通过他们的账户访问它。GCP 资源的例子包括 Google Compute Engine 虚拟机、Google Cloud Storage 存储桶、App Engine 实例和 BigQuery 数据集。GCP 项目还与一个计费账户相关联，所有服务消费的成本都会计费到这个账户。GCP 对象可以按层次结构组织。项目是层次结构的第一级，可以分组到 文件夹 中。每个文件夹可以有另一个文件夹或组织节点作为父节点。组织位于 GCP 层次结构的顶部，并且不能有父节点。

在以下图中，您可以看到由一个组织节点、两个主要文件夹和两个嵌套文件夹组成的层次结构，这些文件夹连接到三个不同的 GCP 项目：

](https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/ml-bgqlml/img/B16722_02_001.jpg)

图 2.1 – 由资源、项目、文件夹和组织组成的 GCP 资源层次结构

根据 GCP 最佳实践，建议您创建不同的项目以分离不同的环境，例如开发、测试、质量保证 和生产。文件夹特别有用，可以隔离属于不同部门或同一公司内部不同团队的作业。创建组织节点不是必需的，但可以用来将整个公司或法律实体的所有作业分组。组织和文件夹节点用于在公司各部门之间分配统一的政策和权限，并具有独特和集中的控制点。

小贴士

要使用 GCP 文件夹，创建组织节点是强制性的。如果未创建组织节点，则每个项目将被视为与其他项目逻辑上分离，并且不能分组到文件夹中。

为了进行本书的动手练习，我们只需创建一个 GCP 项目。这是我们组织本书各章节中创建的所有 BigQuery 数据集的唯一必需品。

现在我们已经了解了 GCP 资源的组织方式，让我们看看如何创建一个新的 Google 帐户。

注册 GCP 帐户

要开始使用 GCP，我们至少需要一个用户。用户是在 身份和访问管理（IAM）系统中配置的成员。IAM 的目标是授予适当的访问权限和权限给适当的成员。GCP 支持不同类型的成员：

Google 帐户：任何可能与 GCP 交互的人，通过电子邮件地址识别，例如 Gmail 帐户。
服务帐户：一个技术用户，不直接与人类用户关联。它被分配给 GCP 服务以与其他资源交互和访问。
user2@companyxyz.com 和 user3@companyxyz.com。
云身份域：类似于 Google Workspace 域，唯一的区别是，这个用户组无法访问 Google 的生产力套件。
Google 组：代表一组帐户。它与电子邮件别名相关联，并可用于将相同的权限和授权分配给多个帐户。

为了我们的目的，我们将使用 Google 提供的免费试用版创建一个简单的 Google 帐户，该试用版可在以下地址找到：cloud.google.com/free：

![图 2.2 – Google Cloud 网页访问 GCP 免费试用

![图 2.2 – 访问 GCP 免费试用的 Google Cloud 网页

此免费选项让您可以免费开始使用 GCP，并提供以下服务：

利用每个 GCP 服务免费层的可能性，包括 BigQuery。此选项没有到期日期。
300 美元的有限信用额度，以克服免费层的限制或使用其他服务。此信用额度在 90 天后到期。

如果你还没有创建 GCP 项目，请先选择免费开始，或者点击登录以访问您现有的 GCP 控制台。出于教育目的，我们将选择免费开始以展示整个账户创建过程，如下面的截图所示：

![图 2.3 – 为 GCP 创建 Google 账户

![图片 B16722_02_003.jpg]

图 2.3 – 为 GCP 创建 Google 账户

如果你没有现有的电子邮件地址，你可以在 GCP 注册过程中直接创建一个 Gmail 账户。在账户创建过程中，您需要指定您的名字和姓氏、现有的或新的电子邮件地址以及一个强大的密码以访问 GCP。

接受隐私条款后，您将被重定向到 GCP 注册过程，该过程基本上由两个步骤组成：

在第一步，您需要选择您的国家，阅读并同意服务条款，然后注册以接收来自 Google 及其合作伙伴的更新。如图 2.4右侧所示，注册页面总结了免费试用版的主要条件：![图 2.4 – GCP 账户创建的第一步

![图片 B16722_02_004.jpg]

图 2.4 – GCP 账户创建的第一步
第二步要求您提供所有必要的 GCP 项目计费信息。这一步要求您提供账单地址和信用卡以开始使用 GCP：![图 2.5 – 创建 GCP 账户所需提供的信息

![图片 B16722_02_005.jpg]

图 2.5 – 创建 GCP 账户所需提供的信息
在过程结束时，选择开始我的免费试用；您将准备好访问 Google Cloud Console 的主页。

小贴士

虽然创建 Google Cloud 账户需要信用卡，但只有在您明确决定将账户从免费层升级到付费版本时，才会使用信用卡。

现在我们已经创建了我们的 Google 账户，并且第一次访问了 Google Cloud Console，在下一节中，我们将探索这个网络界面的主要功能。

探索 Google Cloud Console

Google Cloud Console 允许用户通过图形用户界面访问和使用所有 GCP 资源。

在下面的截图中，您可以查看 Google Cloud Console 及其主要部分：

![图 2.6 – Google Cloud Console 功能概述

![图片 B16722_02_006.jpg]

图 2.6 – Google Cloud Console 功能概述

从左上角开始，你可以看到汉堡按钮以访问导航菜单（1）。此菜单允许你在所有 GCP 资源之间浏览并选择要使用的服务。向右移动，紧接在 GCP 标志之后，你会看到当前 GCP 项目的名称（2），它显示当前正在使用的环境。搜索栏（3），位于页面顶部，允许我们在项目中查找特定的资源或技术，可以被视为导航菜单的替代品。

专注于右上角，我们可以找到（4）。此工具提供了从 Google Cloud Console 直接使用 Linux 命令行的可能性，这是免费的。这个 Linux 环境已经预先配置了 Google Cloud SDK，以便轻松地在你 GCP 项目中配置和管理资源。此外，它还可以用于临时存储数据，因为它提供了 5 GB 的免费容量。

向左移动，你可以看到账户设置（5）功能，用于访问你的 Google 账户资料，并在需要时注销。

屏幕的大部分中央区域被仪表板（6）占据。它包含一些卡片，可以让你一眼了解你的 GCP 项目概览。这些卡片是可以通过右侧的7按钮显示或隐藏的小部件。

现在我们已经查看了 GCP 控制台的首页，我们准备好创建一个新的 GCP 项目，该项目将托管本书的所有动手活动。

创建 GCP 项目

正如我们解释的，GCP 项目是我们使用的所有 GCP 资源的容器。每个项目都有以下特征：

项目名称：在创建阶段选择的一个易于记忆和可读的名称。名称不必是唯一的；它具有纯粹描述性的功能，可以在项目创建后更改。
项目 ID：这是一个唯一的标识符，由用户分配或在创建新项目时由 Google 自动生成。与项目名称不同，它不能被修改。ID 需要在 GCP 中是唯一的。
项目编号：由 GCP 自动生成且用户无法更改的标识符。它在 GCP 中也是唯一的。

在 Google Cloud Console 的项目信息卡片中查看，所有这些标识符都可以轻松读取：

![Figure 2.7 – The Project info widget shows the identifiers of a GCP project

![img/B16722_02_007.jpg]

图 2.7 – 项目信息小部件显示了 GCP 项目的标识符

通过选择当前正在使用的项目名称，我们可以访问我们允许访问的所有 GCP 项目列表：

![Figure 2.8 – By selecting the name of the project in use, it is possible to change it

![img/B16722_02_008.jpg]

图 2.8 – 通过选择正在使用的项目名称，可以更改它

点击会弹出一个窗口，允许我们更改当前项目或浏览 GCP 的组织、文件夹和项目层次结构。在我们的情况下，唯一的现有 GCP 项目是我的第一个项目，这是在注册过程中自动创建的。

让我们逐步了解创建新项目的流程：

通过在窗口右上角选择新建项目按钮，可以创建一个新环境来逻辑上分离云工作负载。就我们的目的而言，我们将创建一个专门的 GCP 项目来托管本书章节中后续的所有动手练习：![图 2.9 – 此窗口允许您选择现有项目或创建新项目

![img/B16722_02_009.jpg]

图 2.9 – 此窗口允许您选择现有项目或创建新项目
在下一步中，您需要填写项目名称。在这种情况下，我们将使用bigqueryml-packt，但您可以选择另一个名称。这也是将您的 GCP 项目链接到父对象（如组织或文件夹）的地方。选择编辑后，您还有机会更改自动生成的项目 ID。通过点击创建按钮，您将创建新项目：![图 2.10 – 新建项目窗口允许您选择项目名称、ID 和位置

![img/B16722_02_010.jpg]

图 2.10 – 新建项目窗口允许您选择项目名称、ID 和位置
几秒钟后，我们将在 GCP 控制台的右上角通过点击铃铛图标收到关于新项目创建的通知：![图 2.11 – 当创建新项目并准备好使用时，GCP 用户会收到通知

![img/B16722_02_011.jpg]

图 2.11 – 当创建新项目并准备好使用时，GCP 用户会收到通知
创建后，新的 GCP 项目也将在项目层次结构中可见，并且可以选择它作为当前工作环境：

![图 2.12 – 项目创建后，可以将其设置为当前项目

![img/B16722_02_012.jpg]

图 2.12 – 项目创建后，可以将其设置为当前项目

现在我们已经创建了一个新项目，是时候开始使用 BigQuery 了。在下一节中，我们将学习在使用之前如何激活该服务。

激活 BigQuery

每个 GCP 服务都可以根据客户需求和需要实现的使用场景来启用或禁用。就我们的目的而言，我们将展示激活 BigQuery 服务的必要步骤，但同样的方法可以扩展到其他 GCP 技术：

小贴士

启用或禁用 GCP 服务不会影响您 GCP 项目的计费。您只需为实际使用的 GCP 组件付费，而不是仅仅因为启用了服务。

第一步是访问 API 和服务库，这可以在 Google Cloud Console 的导航菜单中轻松找到：

图 2.13 – 从 GCP 控制台的导航菜单，可以访问 GCP 服务库

此功能允许您浏览整个 GCP 服务库，并选择要开启或关闭的服务。
如果我们在搜索栏中搜索 bigquery，第一个结果将是 BigQuery API：

图 2.14 – 使用搜索栏查找 bigquery，可以找到 BigQuery API 服务
点击 BigQuery API 后，我们将被重定向到一个专门针对 BigQuery 服务的页面，在那里可以阅读服务的描述，访问 BigQuery 文档，并在之前未启用的情况下启用服务。如果服务已被禁用，直接从导航菜单访问 BigQuery 将会重定向我们到同一页面。
选择启用按钮，GCP 将激活 BigQuery，让您开始使用它。一旦服务有效启用，您将被重定向到服务的仪表板，该仪表板显示了使用统计概览，并允许您使用 禁用 API 按钮禁用此组件。

到目前为止，我们已经创建了一个新的 Google 账户和一个专门的 GCP 项目，并已启用 BigQuery；现在是时候查看 BigQuery 网络界面了。

发现 BigQuery 网络用户界面

当 BigQuery API 启用时，为了访问 BigQuery UI，您可以在 GCP 导航菜单中打开并从 Google Cloud 服务列表中选择 BigQuery。

初看（见下面的截图），BigQuery UI 可能看起来很复杂，因为它包含大量信息和按钮。在屏幕左侧，我们可以看到一个由导航面板（1）占据的列。此面板分为两个主要部分。在上一个部分中，您可以访问以下内容：

查询历史，它跟踪所有之前执行的查询及其执行状态。
保存的查询，一个存储您保存并频繁使用的查询的区域。
作业历史，以跟踪所有批量加载、导出和复制操作及其执行状态。
传输功能使我们能够将数据导入 BigQuery，利用来自 软件即服务（SaaS）应用程序的 BigQuery 数据传输服务，例如 Google Analytics、Google Ads 或 Amazon S3。
计划查询，以定期计划查询或监控已计划执行的查询。
预留，以固定费率模型预留 BigQuery 处理能力。
BI Engine 允许您在 BigQuery 上激活内存层，以进一步提高性能并获得报告活动的亚秒级延迟。
资源允许您浏览不同的 GCP 项目和数据集。

在导航面板的下半部分，我们可以访问和浏览项目、相关的 BigQuery 数据集以及如表、视图和机器学习模型（2）等数据结构：

图 2.15 – BigQuery 网页界面的所有功能

在网页页面的顶部中央，您可以使用 Web 查询编辑器（3）编写 SQL 语句，并使用运行按钮（4）运行这些查询。开发者可以通过右上角的 隐藏编辑器 按钮，或通过选择 编写新查询（5）来隐藏 Web 查询编辑器。在查询编辑器下方，您可以可视化执行查询的结果以及每个选中项的详细信息（6），例如数据集或表。在网页界面的两个部分之间，可以访问 查询调度器 工具（7）。点击更多按钮（8），也可以访问 BigQuery 选项和 SQL 格式化器，后者用于使 SQL 查询易于阅读。

在 bigqueryml-packt 面板的右侧，您可以选择/点击 创建数据集（9）来创建一个新的 BigQuery 数据集。

小贴士

在 BigQuery 选项中，您可以找到启用或禁用 BigQuery 缓存的选项。如果启用缓存，BigQuery 会尝试使用可用的缓存结果。如果查询结果已经在缓存中，则不会执行查询。缓存用于节省计算资源并获得高性能。如果查询包含非确定性函数，例如 CURRENT_TIMESTAMP() 和 NOW()，则不会使用缓存，BigQuery 将执行查询语句。

在本节中，我们分析了 BigQuery 网页界面中所有可用的主要功能。现在，我们可以开始探索 BigQuery 公共数据集并了解如何在我们的项目中使用它们。

探索 BigQuery 公共数据集

收集大量数据对于开发机器学习用例至关重要。这类活动被认为是数据管理领域中最痛苦的工作之一。实际上，它需要工具和最佳实践来定期监控和从物理世界收集信息，将其转换为数据。多亏了 云公共数据集计划，我们被允许使用已经收集并导入到 BigQuery 中的数据。

BigQuery 公共数据集可在Google Cloud Marketplace的数据集部分找到，这些数据集对所有 GCP 用户公开可用，并准备好使用。所有数据集的列表可通过此 URL 访问：console.cloud.google.com/marketplace/browse?filter=solution-type:dataset。这些数据集不仅由谷歌提供，还由许多大公司和公共机构提供，这些机构为维护这个大约 200 个数据集的多学科集合做出了贡献。一些贡献者包括 GitHub、NOAA、NASA、芝加哥市、牛津大学和美国交通部。

公共数据集也可以直接从 BigQuery UI 访问。在接下来的几页中，我们将逐步了解如何开始使用它们。

搜索公共数据集

从 BigQuery UI，我们可以在导航菜单中选择添加数据按钮，然后点击探索公共数据集以打开一个覆盖窗口，该窗口将显示按感兴趣类别划分的 BigQuery 公共数据集。

在下面的屏幕截图中，你可以看到一些 BigQuery 公共数据集：

![图 2.16 – 主 BigQuery UI 中嵌入的 BigQuery 公共数据集视图]

从这个屏幕，你可以上下滚动以探索可用的数据集，使用搜索栏查找特定主题，或使用类别菜单来筛选主题。

为了我们的目的，我们将寻找由芝加哥市发布的与芝加哥出租车行程相关的公开数据。为了找到这个数据集，建议搜索关键词“芝加哥出租车”，并选择唯一一个名为芝加哥出租车行程的项目。

在下面的屏幕截图中，你可以看到数据集的描述：

![图 2.17 – 可从 Google Cloud Marketplace 访问的芝加哥出租车行程公共数据集概述]

Google Cloud Marketplace

![图 2.17 – 可从 Google Cloud Marketplace 访问的芝加哥出租车行程公共数据集概述]

在概述部分，数据集被描述，并在右侧提供了附加信息。在这种情况下，我们可以读到该数据集每月更新，并在芝加哥数据门户上发布。

点击bigquery-public-data项目。浏览这个 GCP 项目，你会找到chicago_taxi_trips数据集，它只包含一个表：taxi_trips。

分析一个表

点击表名将允许您深入了解taxi_trips数据的一些方面。在模式选项卡中，我们可以探索构成所选表的字段。一些列被定义为必需的，而其他列是可空的。感谢数据集的发布者，这个表也得到了很好的文档记录，我们可以阅读每个字段的简短描述。这类信息将有助于我们在构建机器学习模型之前实施新用例的初期阶段：

图 2.18 – 通过导航菜单选择表名可以访问表模式

要深入了解表的技术细节，我们可以转到详细信息选项卡。本节显示了以下相关信息：

表的大小以 GB 为单位。
表中的行数。
表的创建日期以及最后一次更新的时间。
表存储的 BigQuery 区域。在这种情况下，数据存储在多区域 US。

小贴士

行数和最后修改日期为机器学习提供了基本信息。为了训练有效的模型，我们需要确保我们有足够的记录，并且这些记录不是过时的。使用记录数量不足或旧数据可能会产生低质量的机器学习模型。

预览选项卡提供了我们可以从表中收集到的最后可用信息。此功能允许我们查看存储在表中的数据样本，并一眼了解其内容。

在下面的屏幕截图中，您可以使用预览功能可视化表的记录：

图 2.19 – 预览选项卡展示了taxi_trips表的记录样本

小贴士

从SELECT COUNT(*)查询中访问信息。要查看记录样本，建议使用表上的SELECT *。

摘要

在本章的第二部分，我们迈出了 GCP 的第一步。在开始注册过程之前，我们查看 GCP 资源的层次结构，由多个项目、文件夹和组织节点组成。

之后，我们学习了如何创建新账户并利用 Google 提供的免费试用。然后，我们从网络浏览器中探索了 Google Cloud Console，并创建了一个新的 GCP 项目，我们将在下一章中使用它来托管我们的机器学习用例。

完成设置操作后，我们启用了 BigQuery API 以开始访问这个无服务器分析数据仓库。

由于 BigQuery 提供了许多不同的功能，我们逐步介绍了它们，探索了它们的实用性。其中最重要的功能之一是将公共数据集添加到我们的控制台。这一功能使我们能够访问和使用公司及公共机构已经编译好的表格。数据集已准备好使用，并且可以用来开发我们的用例。

对于本章，我们专注于由芝加哥市发布的关于出租车行程信息的表格。这个表格为我们提供了探索表格的技术细节以及如何预览其中数据的机会。

在下一章中，我们将编写我们的第一个 SQL 语句，以便对机器学习模型开发过程中极其宝贵的所有基本操作充满信心。

进一步阅读

以下链接将为您提供本章更多资源：

Google Cloud 试用: cloud.google.com/free
在 GCP 中启用 API: cloud.google.com/endpoints/docs/openapi/enable-api
BigQuery 网页界面: console.cloud.google.com/bigquery
BigQuery 网页界面文档: cloud.google.com/bigquery/docs/bigquery-web-ui
BigQuery 公共数据集市场: console.cloud.google.com/marketplace/browse?filter=solution-type:dataset
BigQuery 公共数据集文档: cloud.google.com/bigquery/public-data
芝加哥市数据门户: data.cityofchicago.org/

第三章：介绍 BigQuery 语法

BigQuery 方言符合标准 ANSI 2011，对于熟悉其他方言并具备 SQL 经验的人来说，学习起来相当容易。在语法方面的主要差异由 BigQuery 扩展表示，这些扩展使我们能够使用诸如机器学习（ML）等高级功能。将 ML 能力引入 SQL 允许不同角色访问它。这种方法的目标是明确地使公司在不同职能中使用 ML 民主化，尽可能多地创造价值。通过 BigQuery ML，Google Cloud 正在填补技术熟练的 ML 技能人员和非常了解公司数据且多年从事相关工作业务分析师之间的差距。

为了增强你对 BigQuery 环境和其方言的信心，我们将探讨以下主题：

创建 BigQuery 数据集
发现 BigQuery SQL
深入了解 BigQuery ML

技术要求

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

一个 GCP 账户来访问 Google Cloud 控制台
一个 GCP 项目来托管 BigQuery 数据集

现在我们已经准备好了技术要求，让我们深入了解创建 BigQuery 数据集的过程。

查看以下视频以查看代码的实际应用：bit.ly/3vR8I7f

创建 BigQuery 数据集

在下一节中创建的数据结构之前，有必要创建一个新的 BigQuery 数据集，该数据集将使用以下章节创建的数据结构。对于每个实践章节，我们将创建一个新的数据集，以隔离每个用例并保持逻辑上分离的结构：

通过浏览 GCP 控制台中的 GCP 导航菜单并选择BigQuery服务来访问 BigQuery UI。
在 BigQuery UI 的导航菜单中选择正确的 GCP 项目后，可以点击创建数据集按钮：

图 3.1 – 创建新的 BigQuery 数据集
在屏幕右侧出现的叠加窗口中，选择你偏好的数据集 ID，并保留所有其他选项使用默认值。为了托管本章的数据结构，我们建议使用名称03_bigquery_syntax。然后，选择创建数据集：

图 3.2 – 创建数据集屏幕

现在我们已经创建了第一个 BigQuery 数据集，让我们概述一下 BigQuery SQL 语法的核心特点。

发现 BigQuery SQL

BigQuery 支持两种不同的 SQL 方言：标准 SQL和旧版 SQL。在本书中，我们将使用标准 SQL，但如果你想要测试来自旧版应用程序的查询，了解旧版 SQL 是什么以及如何启用它可能是有用的。

正如我们已经提到的，BigQuery 是在谷歌内部开发的一个产品，最初是为了处理日志记录而实现的。查询引擎 Dremel 能够支持现在定义为 Legacy SQL 的一组有限的 SQL 操作。

在下面的屏幕截图中，您可以查看如何更改SQL 方言：

图 3.3 – 更改 SQL 方言的查询设置菜单截图

默认情况下，BigQuery UI 配置为使用 Standard SQL，但您可以通过在 SQL 语句的第一行使用特定的选项来更改 SQL 方言，即位于#legacySQL关键字下的更多按钮。查询设置按钮位于 BigQuery UI 的更多按钮下。

小贴士

为了开发新的用例，我们建议您采用 BigQuery Standard SQL，但请记住，您可能会发现仍然基于 Legacy SQL 的现有应用程序。如果您发现查询未通过查询编辑器验证，请在干预 SQL 语句之前尝试切换到 Legacy SQL。

CRUD 操作

在本段中，我们将学习如何执行基本命令，以便在 BigQuery 中创建、读取、更新和删除（CRUD）对象。这不是所有可以与 BigQuery 一起使用的操作的详尽视图，但本节的目标是提供您面对本书下一章的实际操作章节所需的最少知识。

创建

这类语句通常用于在 BigQuery 中创建对象，如表、视图、用户定义函数（UDFs）和机器学习模型，或者向现有表中插入新记录：

作为第一步，让我们在 BigQuery 中创建一个新的空表：
```
CREATE TABLE
  `bigqueryml-packt.03_bigquery_syntax.first_table` 
  ( id_key INT64,
    description STRING);
```
查询语句的前两个词CREATE TABLE是自解释的，用于开始创建新表的创建。之后，我们可以找到我们正在创建的对象的标识符。它由以下字符串通过.字符连接而成：
- GCP 项目的名称：bigqueryml-packt
- BigQuery 数据集的标识符：03_bigquery_syntax
- 要创建的表名：first_table
  
  标识符的字符串也被反引号字符包围，即`。这个字符界定了我们对象名称的开始和结束。
  
  在两个圆括号之间，你可以看到字段列表，字段类型通过逗号字符分隔。在这个例子中，表只包含两个字段：数值型的id_key和文本型的description。
  
  小贴士
  
  如果已经存在具有相同名称的表，则可以使用CREATE OR REPLACE TABLE关键字创建一个新表来替换现有的表。这种技术在需要定期安排脚本多次运行时特别有用。这些关键字会自动清理先前执行的结果。
现在我们已经创建了我们第一个空表，让我们INSERT我们的第一条记录：
```
INSERT INTO
  `bigqueryml-packt.03_bigquery_syntax.first_table` VALUES
  ( 1,
    'This is my first record inserted in BigQuery' );
```
对于将新记录插入到我们的first_table中，我们使用了INSERT INTO和VALUES关键字。在圆括号之间，我们列出了要插入的实际值。在这种情况下，我们选择了整数1作为id_key，以及字符串'This is my first record inserted in BigQuery'，并用单引号括起来。
在表上方，可以创建一个类似于CREATE TABLE的CREATE VIEW语句，唯一的区别在于视图结构基于AS关键字后面的SELECT语句。在这种情况下，first_view具有与first_table相同的结构，并且不对存储在表中的记录应用任何过滤器或转换。

读取

读取操作主要基于SELECT语句，并且可以应用于不同的数据库对象，如表和视图。

让我们在first_table表上执行一个SELECT语句：

SELECT
  *
FROM
  `bigqueryml-packt.03_bigquery_syntax.first_table`
WHERE
  id_key=1;

要从表或视图中读取数据，必须使用SELECT关键字，后跟要读取的字段列表或通配符*，然后是FROM关键字和源数据结构的标识符。还可以包含一个WHERE子句来表示我们想要应用的所有逻辑过滤器。在这种情况下，我们只选择具有id_key=1的记录，这与我们之前插入到表中的唯一记录相对应。

小贴士

不建议使用通配符*，尤其是在具有大量列的表上。由于 BigQuery 具有列式存储，仅选择真正需要的字段可以显著提高查询的性能并降低计算成本。

在具有嵌套SELECT语句的层次查询中，可以使用WITH子句来提高查询的可读性：

作为第一步，让我们创建一个嵌套的SELECT语句：

SELECT COUNT(*) FROM (
    SELECT
      *
    FROM
      `bigqueryml-packt.03_bigquery_syntax.first_table`
    WHERE
      id_key=1
  );

之后，我们可以使用WITH子句重写相同的逻辑。查询变成了这个：
```
WITH records_with_clause AS (SELECT *
    FROM
      `bigqueryml-packt.03_bigquery_syntax.first_table`
    WHERE
      id_key=1)

SELECT COUNT(*) FROM records_with_clause;
```
在第二个查询中，WITH子句嵌入了AS关键字后面的逻辑，并用圆括号括起来。在定义了名为records_with_clause的WITH子句之后，这个查询的逻辑可以在下一个SELECT COUNT语句中再次调用。

小贴士

WITH子句不会创建临时表。使用WITH子句可以提高查询的可读性，尤其是在存在多个嵌套SELECT语句的情况下，但它不会影响查询的性能。

BigQuery 提供了利用许多其他操作符的可能性，这些操作符在本章中不会详细描述，因为它们在动手练习中不会广泛使用。这些附加操作符允许你执行以下操作：

使用ORDER BY子句根据特定的字段列表对查询结果进行排序。
使用COUNT、SUM、MAX、AVG以及GROUP BY和HAVING子句对查询结果应用聚合。
使用 NEST、UNNEST、ARRAY_AGG 和 ARRAY_LENGTH 管理数组数据类型。
使用 INNER JOIN、LEFT OUTER JOIN、RIGHT OUTER JOIN 和 CROSS JOIN 连接两个或多个表。

更新

尽管 BigQuery 是作为一个分析工具诞生的，但它支持更新操作，如 UPDATE 和 MERGE，并且可以用于更改 BigQuery 表中的现有记录。

为了更改记录或记录集的值，我们可以使用以下方式的 UPDATE 语句：

UPDATE
    `bigqueryml-packt.03_bigquery_syntax.first_table`
SET
    description= 'This is my updated description'
WHERE 
    id_key=1;

在代码的前两行中，UPDATE 关键字后面跟着要应用操作的表的标识符。之后，SET 关键字定义了应更改的列。在这种情况下，description 将被修改。

WHERE 子句允许您仅对匹配过滤器的记录应用 UPDATE 操作。在这种情况下，只有 id_key 等于 1 的记录受到影响。

更新表的另一个强大语句是 MERGE 函数。此函数可以在单个 SQL 语句中应用插入、更新和删除操作，以合并两个不同表的记录。

删除

删除操作特别有用，可以删除记录或从 BigQuery 中删除对象以防止存储成本：

作为第一步，我们可以使用以下 DELETE 语句从 first_table 表中删除一条记录：
```
DELETE
    `bigqueryml-packt.03_bigquery_syntax.first_table`
WHERE 
    id_key=1;
```
如果我们分析 SQL 代码，我们可以看到 DELETE 关键字后面跟着要应用操作的表的标识符。WHERE 子句过滤要删除的记录集。在这种情况下，只有 id_key 等于 1 的记录受到影响。
另一种从表中删除记录的方法是使用 TRUNCATE TABLE 操作符。此函数允许您使用单个语句删除所有记录：
```
TRUNCATE TABLE 
  `bigqueryml-packt.03_bigquery_syntax.first_table`;
```
在 TRUNCATE 之后，我们的 first_table 将继续存在，但将不包含任何记录。
要删除整个表及其结构，我们可以使用 DROP TABLE 关键字：
```
DROP TABLE 
  `bigqueryml-packt.03_bigquery_syntax.first_table`;
```
删除表将从数据集中移除它，使得数据结构不可访问。如果我们探索 03_bigquery_syntax 数据集的对象列表，我们可以看到 first_table 表不再可见：

![图 3.4 – 受 DROP TABLE 语句影响的表不再可见

![图片 B16722_03_004.jpg]

图 3.4 – 受 DROP TABLE 语句影响的表不再可见

在这种情况下，一个有趣的方面是，建立在 first_table 表之上的 first_view 仍然可见。
如果我们尝试对其执行 SELECT 语句，将会引发以下错误：![图 3.5 – 当底层表被删除时查询视图会引发错误

![图片 B16722_03_005.jpg]

图 3.5 – 当底层表被删除时查询视图会引发错误

由 BigQuery 生成的错误会通知用户，底层表已不再可用且无法找到。
为了保持我们的数据集一致性，最好也使用DROP VIEW语句删除视图：
```
DROP VIEW 
  `bigqueryml-packt.03_bigquery_syntax.first_view`;
```
删除视图类似于删除表，但这个操作只影响元数据，因为视图实际上并不存储任何记录。

在本章的这一部分，我们发现了我们可以使用 BigQuery SQL 执行的主要操作；现在是我们深入 BigQuery ML 及其语法的时候了。

深入 BigQuery ML

在 BigQuery 中开发 ML 模型涉及三个主要步骤：

模型创建，在这个阶段，你需要选择 ML 模型的特征和标签以及调整 ML 模型的选项。在这个阶段，BigQuery 将在你选择的训练集上运行 ML 模型的训练。
模型评估允许你在不同的记录集上测试之前步骤中训练的模型，以防止任何过拟合。
模型使用：当 ML 模型准备就绪时，我们可以将其应用于新的数据集，以便根据可用的特征进行预测或标签分类。

在接下来的段落中，我们将查看这三个阶段的语法以及这些语句是如何使用代码占位符构建的。

创建 ML 模型（训练）

当你确定了 ML 用例以及用于训练模型的记录集后，你可以开始使用以下查询来训练模型：

CREATE MODEL`<project_name>.<dataset_name>.<ml_model_name>`
TRANSFORM (<list_of_features_transformed>
OPTIONS(<list_of_options>)
AS <select_statement>;

与创建 BigQuery 表的创建过程非常相似，训练新模型的语句包括以下内容：

CREATE MODEL关键字。
然后是新 ML 模型的名称。这个标识符由项目名称、数据集名称和 ML 模型名称的连接组成，由.字符分隔，并用反引号包围。
TRANSFORM子句不是必需的，但非常有用。它允许我们列出在训练之前应用于特征的预处理转换。将这些准备函数放在这里允许我们在实际使用模型时自动应用相同的操作。
一个OPTIONS列表要求我们指定我们想要使用的model_type，例如线性回归或逻辑回归。这个选项列表也用于通过input_label_cols关键字选择 ML 模型的标签列表。其他选项可以用来调整 ML 模型，这些将在本书的下一章节中解释，并伴有实际操作练习。
AS关键字后跟SELECT语句。这个语句定义了 ML 模型将要训练的记录集。

除了CREATE MODEL语句之外，我们还可以使用以下内容：

使用CREATE OR REPLACE MODEL创建新模型或用相同名称替换现有模型。
使用CREATE MODEL IF NOT EXISTS仅在不存在具有相同名称的模型时训练新模型。

现在我们已经了解了如何在 BigQuery ML 中创建 ML 模型，让我们看看下一个阶段：模型的评估。

评估 ML 模型

在一组记录上训练 ML 模型后，极其重要的是在不同于训练集的第二数据集上评估其性能，以避免任何过拟合。

重要提示

在术语过拟合中，我们指的是当 ML 模型从训练数据集中学习得很好，但在新的数据集上表现不佳的情况。这通常发生在模型过于依赖训练数据集的细节，并受到其中存在的噪声的影响。

根据在模型创建过程中选择的 ML 算法，我们可以选择不同的评估函数。

评估函数

此函数可用于线性回归、逻辑回归、k-均值聚类、矩阵分解和基于 ARIMA 的时间序列模型：

SELECT *
FROM ML.EVALUATE(
    MODEL `<project_name>.<dataset_name>.<ml_model_name>`,
          `<project_name>.<dataset_name>.<evaluation_table>`
    , STRUCT(<threshold> AS threshold));

ML.EVALUATE函数仅返回一条记录，其中包含我们已训练和评估的 ML 模型的关键性能指标。它返回的指标取决于模型类型。查询占位符由以下组成：

一个初始的SELECT *语句，允许我们检索评估阶段返回的所有字段。
从ML包中调用评估函数：ML.EVALUATE。
我们非常熟悉的 ML 模型标识符的语法：项目、数据集和模型名称。
<evaluation_table>是将在其上评估 ML 模型的表格。此表可以用SELECT语句替换，不是强制的。如果您不提供评估阶段的表，BigQuery 将使用整个训练集或其一部分来评估您的 ML 模型。
可选的<threshold>，可用于评估逻辑回归模型。如果此值未指定，BigQuery 将使用0.5作为默认值。

小贴士

要使用ML.EVALUATE函数，评估集的字段名称应与在模型创建期间使用的训练数据集的字段名称相匹配。

混淆矩阵函数

此函数返回一个混淆矩阵来评估逻辑回归和多类逻辑回归模型的性能：

SELECT *
FROM ML.CONFUSION_MATRIX(
    MODEL `<project_name>.<dataset_name>.<ml_model_name>`,
          `<project_name>.<dataset_name>.<evaluation_table>`
    , STRUCT(<treshold> AS threshold));

此函数返回两行两列，包含假阳性、假阴性、真阳性和真阴性的数量。与EVALUATE函数相比，在语法方面的唯一区别是通过使用ML.CONFUSION_MATRIX函数来表示。

ROC 曲线函数

此函数只能用于逻辑回归模型，并根据传递给函数的阈值数组返回多个记录：

SELECT *
FROM ML.ROC_CURVE(
    MODEL `<project_name>.<dataset_name>.<ml_model_name>`,
          `<project_name>.<dataset_name>.<evaluation_table>`
    , GENERATE_ARRAY(<treshold_1>, <treshold_2>, <treshold_n> ));

我们可以从上一段分析的其他评估函数中看到的唯一有意义的区别是存在一个阈值数组。GENERATE_ARRAY函数创建一个数组，其中包含由逗号分隔的阈值值，并用圆括号括起来。

此函数的输出包括输入的阈值、召回值、假阳性率以及真阳性、假阳性、真阴性和假阴性的数量。

我们已经了解了 BigQuery ML 模型的所有评估技术，现在是时候看看如何应用它们并获取结果了。

使用 ML 模型

当我们对我们的 ML 模型的性能满意时，下一步就是使用它来实现我们的目标，并最终从实施中获得商业价值。

预测函数

此函数适用于线性回归、逻辑回归、多类逻辑回归、k-均值聚类和导入的 TensorFlow 模型：

SELECT *
FROM ML.PREDICT(
    MODEL `<project_name>.<dataset_name>.<ml_model_name>`,
          `<project_name>.<dataset_name>.<features_table>`
    , STRUCT(<treshold> AS threshold));

查询由以下内容组成：

使用 SELECT * FROM 语句获取 ML.PREDICT 函数返回的所有记录和字段。
ML.PREDICT 关键字，它接受用于预测的 ML 模型名称（<ml_model_name>）和包含要执行预测的特征的表（<features_table>）作为输入。
可选地，您可以为逻辑回归模型使用 <threshold> 值，后跟 AS threshold 关键字。

ML.PREDICT 函数为 <features_table> 中的每一行生成并返回一个记录。每一行由特征和预测标签组成。

预测函数

此函数只能用于时间序列 ML 模型：

SELECT *
FROM ML.FORECAST(
    MODEL `<project_name>.<dataset_name>.<ml_model_name>`,
    STRUCT(<horizon_value> AS horizon, 
           <confidence_value> AS confidence_level));

与 PREDICT 语句不同，它不需要表作为输入。它允许我们选择以下内容：

一个特定的 <horizon_value>。范围代表应预测的时间点数量。如果您不指定此值，BigQuery 将使用 3 作为默认值。
confidence_level，表示预测值中位于预测区间内的百分比。

删除 ML 模型

删除 ML 模型相当简单，语法与取消表类似：

DROP MODEL `<project_name>.<dataset_name>.<ml_model_name>`;

使用 DROP MODEL 关键字后跟 BigQuery ML 模型的标识符，您可以从数据集中删除该资产。

你还可以使用 DROP MODEL IF EXISTS 关键字，这可以防止如果 BigQuery ML 模型已经被删除时发生错误。此操作仅在模型存在于数据集中时才会删除模型：

DROP MODEL IF EXISTS
`<project_name>.<dataset_name>.<ml_model_name>`;

当模型被删除时，我们可以确信不会消耗资源来保持它在 BigQuery 中的活跃状态。

摘要

在本章中，我们学习了 BigQuery 语法的要点。在创建数据集之后，我们发现了如何创建表、插入记录以及读取存储在表中的行。你还学习了如何更新现有记录以及如何删除不再有用的行和对象，例如表和视图。

完成对 BigQuery SQL 语法的概述后，我们深入探讨了 ML 模型生命周期的主要阶段。实现用例的三个主要阶段是创建、评估和使用 ML 模型。对于训练阶段，我们了解到如何使用 SQL 训练和创建新模型。之后，我们了解了所有可以用来监控训练模型有效性的函数，评估其关键性能指标。最后，我们看到了如何在新数据集上使用训练模型进行推断以获得结果和预测、预报或建议。在本章结束时，我们还学习了如何删除不再有用的 BigQuery ML 模型。

现在我们已经清楚地理解了语法以及我们可以在 BigQuery 中使用的所有功能，是时候将这些概念应用到我们的第一个实际案例中。在下一章中，我们将开发我们的第一个 BigQuery ML 模型，用于预测纽约市一个重要自行车租赁服务中自行车行程的估计时长。

第二部分：深度学习网络

在本节中，解释并展示了使用 BigQuery ML 的实际动手示例来介绍回归机器学习模型。

本节包含以下章节：

第四章，使用线性回归预测数值
第五章，使用二元逻辑回归预测布尔值
第六章，使用多类逻辑回归对树木进行分类

第四章：使用线性回归预测数值

对于需要根据预算和资源来规划战略的公司来说，预测数值可能具有极大的价值。在大多数行业中，预测数字可能比竞争对手带来巨大的商业优势，并能够开启新的商业场景。

线性回归起源于统计学领域，成为执行此类任务最知名的机器学习技术之一。在数据科学中，线性回归模型用于寻找和量化不同变量之间原因和效果之间的关系。这类模型在需要预测数值测量的不同商业场景中非常有用。

在本章中，我们将通过利用大查询 ML 构建线性回归模型的所有必要步骤，这将简化并加速开发过程的各个阶段。

通过采用逐步和渐进的方法，我们将涵盖以下主题：

介绍业务场景
发现线性回归
探索和理解数据集
训练线性回归模型
评估线性回归模型
利用线性回归模型
提炼业务结论

让我们开始吧！

技术要求

本章要求您能够访问网络浏览器并能够利用以下功能：

一个 GCP 账户以访问 Google Cloud Console
一个 GCP 项目来托管 BigQuery 数据集

现在，让我们深入分析和发展我们的大查询 ML 线性回归模型的部分。

查看以下视频以查看代码的实际应用：bit.ly/2Rru9wA

介绍业务场景

想象一下，你是一名在纽约市一家大型公司工作的商业分析师。你的公司管理着全国最大的共享单车项目。它利用了 10,000 辆自行车，并在纽约的不同地区（曼哈顿、布鲁克林、皇后区和泽西城）实现了 600 个站点。

以下是从纽约市的一个共享单车站拍摄的照片：

![图 4.1 – 纽约市共享单车服务由 Citi Bike 提供

]

图 4.1 – 由 Citi Bike 提供的纽约市共享单车服务

多亏了公司的远见和创新精神，自 2013 年以来已经收集了大量的数据，并且每天都在更新。这些数据包含了很多关于服务使用情况的信息，可以用来提取非常有趣的统计数据。

在撰写本文时，共享单车服务对所有已注册每周、每月或年度订阅的客户开放。然而，这对那些只在城市逗留几天的人（如游客或商务旅行者）来说既不便利也不容易获得。

考虑到在纽约市仅停留几天的庞大人群，公司希望人们能够仅租用几小时的自行车。因此，管理层正在考虑启用新的按使用付费的租赁选项的可能性。

公司的目标是为这部分客户创造一个完全数字化的体验，并正在考虑开发一个新移动应用程序。如果客户提前表明他们的出发站和到达站，移动应用程序应该能够预测平均旅行时间和行程的成本估算。多亏了这个功能，客户可以提前知道旅行时间是否与他们的时间表相匹配，以及与其他公共交通服务相比是否更便宜。

公司的一位经理可能会要求你使用机器学习（ML）来开发将被引入新移动应用程序的预测系统。该机器学习系统应使用已收集并存储在 BigQuery 公共数据集中的数据来预测自行车租赁的旅行时间。

既然我们已经解释并理解了问题陈述，让我们来看看我们可以使用的机器学习技术来预测诸如旅行时间这样的数值。

发现线性回归

线性回归是我们可以在拥有连续数值进行预测时应用的最简单技术之一。这是一个众所周知的算法，最初在统计学中引入，用于分析不同变量之间的相关性。

重要提示

在统计学中，回归一词表示两个变量是相关的。这个术语描述了因果关系。原因被称为自变量，而效果被称为因变量。因变量可以作为自变量的函数来计算。

下面的图表显示了两个变量之间简单线性关系的图形表示：

![图 4.2 – 简单线性回归的表示

![图片 B16722_04_002.jpg]

图 4.2 – 简单线性回归的表示

线性回归模型试图通过找到标签与其特征之间最佳线性关系来预测标签。如果机器学习模型只使用一个输入变量，则该模型定义为简单线性回归。如果 ML 模型基于多个特征，则称为多元线性回归。

在我们的业务场景中，行程的持续时间可以用一个数值来表示，因此我们可以使用线性回归方法来训练我们的机器学习模型。简单线性回归的一个例子是利用仅一个变量，例如起止站之间的距离，来预测结果。多元线性回归基于多个输入变量。在我们的场景中，这可能包括起止站之间的距离、骑行者的年龄以及租赁发生的星期几。

训练线性回归模型意味着尝试找到可以用于输入变量（称为特征）和输出变量（称为标签）之间线性方程的系数值。

我们不会在这本书中详细介绍线性回归的所有细节，但我们可以提及一些线性关系的例子，以更好地理解这个概念。在现实生活中，我们可以找到许多可以用线性回归很好地估计的度量，例如以下内容：

人的体重取决于他们的身高。
公司的收入是客户数量的函数。
飞机消耗的燃料量取决于航行的距离。

现在我们已经学习了线性回归的基础知识，是时候看看我们将用于构建机器学习模型的数据集了。

探索和理解数据集

在深入到机器学习实现之前，分析我们用例中可用的数据是必要的。由于机器学习训练基于示例，我们需要清楚地了解要考虑哪些数据，并检查可用记录的质量。

小贴士

数据科学家和商业分析师花费大量时间和资源来清楚地理解数据集，检查它们的质量，并准备它们。尽管这些操作似乎与实现机器学习算法没有直接联系，但如果你希望得到可靠的结果，它们是至关重要的。模型的实际训练是开始于理解数据、控制其质量并准备数据这一更长旅程的最后一英里。

让我们从清楚地了解我们数据集中用于构建用例的信息开始。

理解数据

为了清楚地了解我们将要用于实现此用例的数据集，我们需要做以下事情：

登录 Google Cloud 控制台，从导航菜单访问 BigQuery 用户界面：![图 4.3 – 从 GCP 控制台访问 BigQuery 服务

![img/B16722_04_003.jpg]

图 4.3 – 从 GCP 控制台访问 BigQuery 服务
在我们第二章，“设置您的 GCP 和 BigQuery 环境”中创建的项目下创建一个新的数据集。为此，我们需要在 BigQuery 导航菜单中选择我们的 GCP 项目，并点击 04_nyc_bike_sharing，保留所有其他选项的默认值：![图 4.4 – 创建新的 BigQuery 数据集以托管我们的用例资产

图 4.4 – 创建新的 BigQuery 数据集以托管我们的用例资产

此数据集将包含我们的 BigQuery ML 模型以及我们在本章后续步骤中创建的所有中间表。

一旦创建了数据集，它将在 BigQuery 导航菜单中可见，如下截图所示：

![图 4.5 – 新数据集在 GCP 项目中可用，以及在 BigQuery 导航菜单中可见

图 4.5 – 新数据集在 GCP 项目中可用，并在 BigQuery 导航菜单中可见
打开托管所有 BigQuery 公共数据集的 bigquery-public-data GCP 项目，浏览项目直到找到 new_york_citibike 数据集。在这个公共数据集中，我们将看到两个 BigQuery 表：citibike_stations 和 citibike_trips。第一个表是我们自行车共享服务的站点注册表，而第二个表对我们用例来说最有兴趣。我们现在可以开始分析它：![图 4.6 – 纽约 Citi Bike 公共数据集包含两个可以用于我们业务场景的不同表

图 4.6 – 纽约 Citi Bike 公共数据集包含两个不同的表，这些表可以用于我们的业务场景
让我们在 BigQuery 导航菜单中点击 citibike_trips 表以访问该表的架构：![图 4.7 – citibike_trips 表的结构列出了所有可以作为标签和特征的字段可以用作标签和特征

图 4.7 – citibike_trips 表的结构列出了所有可以作为标签和特征的字段

该表有良好的文档说明，对于每一列，我们可以轻松理解其名称、数据类型和内容的意义。

此表包含对我们用例相关的信息：tripduration 字段表示每次自行车租赁的持续时间，以秒为单位。tripduration 的值是一个数值，这是我们业务场景中想要预测的，因此它将成为我们的标签。

表格中的所有其他字段都是潜在的特征。实际上，我们有关于起始站和终点站、行程发生时间以及一些关于客户的信息，例如他们的年龄。所有这些列都可能是特征的良好候选者，因为站点的位置与要通过的距离直接相关，并影响行程的持续时间。此外，骑行开始的时间可能会影响持续时间，因为在某些日子里，街道可能会更繁忙。然后，从客户的角度来看，我们可能会猜测年轻人骑得比老年人快。从模式的角度来看，我们可以得出结论，这个表格代表了一个很好的数据集，用于开发我们的机器学习模型，但我们需要进一步检查我们的初步猜测。
作为下一步，让我们看看表格中有多少条记录，以及这些记录是否足够满足我们的需求。

点击详情标签页，我们可以看到该表格包含超过 5800 万条记录：

![图 4.8 – citibike_trips 表的详情标签页显示了可用的记录数

图 4.8 – citibike_trips 表的详情标签页显示了可用的记录数

我们可以非常自信地使用如此大量的数据来构建 ML 模型。

在本节中，我们了解了仅通过分析 BigQuery 用户界面提供的元数据，我们可以获得多少信息。现在，是时候查看这个表格中的实际数据并有效地使用它了。

检查数据质量

数据质量对于构建健壮的机器学习模型至关重要。ML 模型从示例中学习。如果示例包含错误数据，模型不可避免地会从这些错误中学习并在实际使用中应用它们。

让我们开始分析用于构建我们的 ML 模型的数据库集：

首先，我们将关注tripduration字段。这是我们希望用我们的机器学习模型进行预测的列，它代表我们的标签：
```
SELECT COUNT(*)
FROM
  `bigquery-public-data.new_york_citibike.citibike_trips`
WHERE
  tripduration is NULL
  OR tripduration<=0;
```
这个查询语句计算了tripduration为空或小于零的行数。尽管表格描述报告称该数据集只包含持续时间大于 1 分钟的行程，但我们可以立即注意到这个查询的结果是一个大于 0 的数字。事实上，我们可以找到超过五百万条tripduration字段未正确赋值的记录。由于我们不能在标签的空值或错误值上训练模型，我们需要将这些记录排除在我们的用例之外。
接下来，我们将检查tripduration字段的最低值和最高值，以证明任何可能对我们的机器学习模型性能产生不良影响的异常值：
```
SELECT  MIN (tripduration)/60 minimum_duration_in_minutes,
        MAX (tripduration)/60  maximum_duration_in_minutes
FROM
  `bigquery-public-data.new_york_citibike.citibike_trips`
WHERE
  tripduration is not NULL
  AND tripduration>0;
```
虽然最小租赁时间是 1 分钟，但我们看到最大值与自行车共享服务的正常功能不兼容。实际上，最大时长超过 300,000 分钟，这大约相当于超过 225 天的租赁期。

在下面的屏幕截图中，你可以看到查询的结果：

![Figure 4.8 – citibike_trips 表的详细信息标签页显示了可用的记录数

图 4.9 – 查询结果，证明了tripduration列中存在异常值

在准备我们的数据集时，我们会考虑所有这些因素，以避免对机器学习模型造成任何影响。
然后，我们可以对所有可能的机器学习模型特征列应用类似的检查，排除那些tripduration值非显著性的记录：
```
SELECT  COUNT(*)
FROM
  `bigquery-public-data.new_york_citibike.citibike_trips`
WHERE
  (tripduration is not NULL
  AND tripduration>0) AND (
  starttime is NULL
  OR start_station_name is NULL
  OR end_station_name is NULL
  OR start_station_latitude is NULL
  OR start_station_longitude is NULL
  OR end_station_latitude is NULL
  OR end_station_longitude is NULL);
```
使用这个查询语句，我们只关注租赁时长大于零且非空的记录。查询的目标是检查所有其他潜在特征字段不为空。

在这种情况下，查询返回零。因此，我们可以确信，排除tripduration为NULL的行，我们将在其他列得到有意义的值。
之后，我们可以分析birth_year列，该列代表使用自行车共享服务的客户的出生年份：
```
SELECT  COUNT(*)
FROM
  `bigquery-public-data.new_york_citibike.citibike_trips`
WHERE
  (tripduration is not NULL
  AND tripduration>0)
  AND ( birth_year is NULL);
```
SELECT COUNT (*)语句寻找客户出生年份为空的记录。查询过滤了tripduration为NULL或小于零的记录。

执行查询后，我们可以立即注意到有超过五百万条记录的birth_year字段为NULL。我们需要在用例的后续阶段过滤这些记录。

小贴士

为了加速在表上编写SELECT语句的过程并避免任何错误，BigQuery 允许你使用查询表按钮，该按钮会自动生成一个 SQL 占位符，你只需选择要提取的字段。此外，你还可以从导航菜单中选择表名，或从模式标签中选择列名，以自动将所选对象的名称包含在你正在编写的 SQL 查询中。

现在我们已经对我们的数据集进行了质量检查，让我们将行划分为三个不同的表：训练、评估和预测。

数据集划分

开发机器学习模型的主要原则之一是将我们的数据集划分为训练集和评估集，然后在不同记录上应用机器学习模型。

让我们从以下步骤开始划分数据集：

要了解数据如何在年份和月份之间分布，我们可以使用以下查询语句：
```
SELECT
  EXTRACT (YEAR FROM starttime) year,
  EXTRACT (MONTH FROM starttime) month,
  count(*) total
FROM
  `bigquery-public-data.new_york_citibike.citibike_trips`
WHERE 
  EXTRACT (YEAR FROM starttime)=2017 OR
  EXTRACT (YEAR FROM starttime)=2018
  AND (tripduration>=3*60 AND tripduration<=3*60*60)
  AND  birth_year is not NULL
  AND birth_year < 2007
GROUP BY
  year, month 
ORDER BY
  year, month asc;
```
SELECT 语句从 starttime 字段中提取年份和月份，该字段表示自行车行程开始的精确时刻。

要提取整个时间戳的一部分，我们可以使用 EXTRACT 函数，该函数接受一个参数，如 YEAR、MONTH、QUARTER、WEEK、DAYOFYEAR 或 DAYOFWEEK 作为输入，然后跟随着 FROM 关键字和包含日期表达式的字段。

该查询已经排除了我们在上一节中找到的所有不良记录，并专注于 2017 和 2018 年。

为了排除 tripduration 列中的异常值，我们只考虑了租赁时间至少为 3 分钟且最多为 3 小时的行。

我们还可以添加一个过滤条件到客户的出生年份，通过过滤所有 birth_year 为空的记录，并忽略所有在 2007 年之后出生的客户。

该查询通过 GROUP BY 子句计算每年和每月分割结果的数量，并按照 ORDER BY 子句中指定的升序模式对这些时间段进行排序。

在下面的屏幕截图中，您可以看到查询的结果：

![图 4.10 – 查询结果按月描述了分割情况

图 4.10 – 查询结果按月描述了分割情况

从查询结果中，我们可以看到数据集从 2017 年 4 月到 2018 年 5 月。我们可以使用一个经验法则，保留 80% 的数据用于训练，10% 用于评估，剩余的 10% 用于预测。通过将此规则应用于我们的数据集，我们将使用前 11 个月进行训练阶段，接下来的 2 个月用于评估阶段，最后一个月用于预测阶段。

应用我们在上一步中决定的内容，让我们创建一个只包含用于训练我们的 BigQuery ML 模型的行的表格：

CREATE OR REPLACE TABLE `04_nyc_bike_sharing.training_table` AS
  SELECT 
    tripduration/60 tripduration,
                        starttime,
                        stoptime,
                        start_station_id,
                        start_station_name, 
                        start_station_latitude,
                        start_station_longitude, 
                        end_station_id,
                        end_station_name, 
                        end_station_latitude,
                        end_station_longitude, 
                        bikeid,
                        usertype,
                        birth_year, 
                        gender,
                        customer_plan
  FROM
    `bigquery-public-data.new_york_citibike.citibike_trips`
  WHERE 
    (
       (EXTRACT (YEAR FROM starttime)=2017 AND
         (EXTRACT (MONTH FROM starttime)>=04 OR
           EXTRACT (MONTH FROM starttime)<=10))
        OR (EXTRACT (YEAR FROM starttime)=2018 AND
          (EXTRACT (MONTH FROM starttime)>=01 OR
            EXTRACT (MONTH FROM starttime)<=02))
    )
    AND (tripduration>=3*60 AND tripduration<=3*60*60)
    AND birth_year is not NULL
    AND birth_year < 2007;

查询的结果存储在我们创建的新 04_nyc_bike_sharing.training_table 表中，以支持我们用例的后续步骤。

SELECT 语句从 BigQuery 公共数据集的 citibike_trips 表中提取所有字段，并将 tripduration 的值从秒转换为分钟。

WHERE 子句允许我们只考虑我们想要用于训练阶段的月份。时间范围从 2017 年 4 月到 2018 年 2 月。我们还在同一个子句中应用了来自数据质量检查的过滤器。

现在我们已经定义了训练数据集，我们可以创建另一个表，专门用于包含用于评估我们的机器学习模型的记录：

CREATE OR REPLACE TABLE `04_nyc_bike_sharing.evaluation_table` AS
SELECT 
    tripduration/60 tripduration,
                       starttime,
                       stoptime,
                       start_station_id,
                       start_station_name, 
                       start_station_latitude,
                       start_station_longitude, 
                       end_station_id,
                       end_station_name, 
                       end_station_latitude,
                       end_station_longitude, 
                       bikeid,
                       usertype,
                       birth_year, 
                       gender, 
                       customer_plan
              FROM
    `bigquery-public-data.new_york_citibike.citibike_trips`
              WHERE 
    (EXTRACT (YEAR FROM starttime)=2018 AND 
      (EXTRACT (MONTH FROM starttime)=03 OR 
        EXTRACT (MONTH FROM starttime)=04))
    AND (tripduration>=3*60 AND tripduration<=3*60*60)
    AND  birth_year is not NULL
    AND birth_year < 2007;

该查询与用于创建训练表的语句非常相似。唯一的区别是 WHERE 子句中我们选择的时期。对于 evaluation_table，我们的 SELECT 语句专注于 2018 年 3 月和 4 月的记录，这些记录之前已被排除在训练表之外。

使用相同的方法，我们也可以创建用于测试我们的机器学习模型的表：

CREATE OR REPLACE TABLE `04_nyc_bike_sharing.prediction_table` AS
SELECT 
    tripduration/60 tripduration,
                    starttime,
                    stoptime,
                    start_station_id,
                    start_station_name, 
                    start_station_latitude,
                    start_station_longitude, 
                    end_station_id,
                    end_station_name, 
                    end_station_latitude,
                    end_station_longitude, bikeid,
                    usertype, birth_year, gender, 
                    customer_plan
FROM
    `bigquery-public-data.new_york_citibike.citibike_trips`
WHERE 
    EXTRACT (YEAR FROM starttime)=2018
    AND EXTRACT (MONTH FROM starttime)=05
    AND (tripduration>=3*60 AND tripduration<=3*60*60)
    AND birth_year is not NULL
    AND birth_year < 2007;

查询将应用必要的逻辑，但只会考虑 2018 年 5 月的月份。

现在我们已经分割了数据集，并且清楚哪些记录用于训练、评估和测试阶段，让我们深入了解 ML 模型的创建。

训练线性回归模型

训练 BigQuery ML 模型不是一个一次性操作，而是一个可能需要多次尝试和迭代的过程，以更接近最终目标，即开发出符合业务场景要求的有效资产，具有良好的性能。对于我们的用例，我们将尝试多次改进我们的 ML 模型。让我们开始吧：

首先，让我们开始训练一个新的名为trip_duration_by_stations的机器学习模型：
```
CREATE OR REPLACE MODEL `04_nyc_bike_sharing.trip_duration_by_stations`
OPTIONS
  (model_type='linear_reg') AS
SELECT
  start_station_name,
  end_station_name,
  tripduration as label
FROM
  `04_nyc_bike_sharing.training_table`;
```
在这个语句中，我们可以注意到CREATE OR REPLACE MODEL关键字，它用于创建一个新的模型。该关键字后面跟着模型的标识符，该标识符是通过连接数据集和 ML 模型名称来表示的。

在这些第一行之后，我们有OPTIONS关键字，其中指定了要使用的机器学习模型的类型。在这种情况下，我们使用的是由model_type='linear_reg'标识的线性回归。

在OPTIONS之后，我们需要指定机器学习模型将要训练的记录集。对于这次首次尝试，我们将决定只使用两个特征：自行车行程的起始站和终点站名称。

使用as label关键字，我们指示 BigQuery 将tripduration用作我们机器学习模型的标签。作为替代，可以在包含INPUT_LABEL_COLS关键字的OPTIONS列表中包含标签，如下面的代码片段所示：
```
OPTIONS
  (model_type='linear_reg'
 input_label_cols=['tripduration'])
```
几秒钟后，BigQuery ML 模型将被创建并在导航菜单下的04_nyc_bike_sharing数据集中可用。选择 ML 模型并点击trip_duration_by_stations。

在这种情况下，我们将关注平均绝对误差。这个值表示实际值和标签预测值之间的平均距离。

如以下截图所示，它非常接近 7 分钟：

![Figure 4.11 – The Evaluation tab shows some key performance indicators of the ML model

![img/B16722_04_011.jpg]

图 4.11 – 评估选项卡显示了机器学习模型的一些关键性能指标
现在，让我们尝试用其他可以带来额外价值的特征来丰富 ML 模型：
```
CREATE OR REPLACE MODEL `04_nyc_bike_sharing.trip_duration_by_stations_and_day`
OPTIONS
  (model_type='linear_reg') AS
SELECT
  start_station_name,
  end_station_name,
    IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR
          EXTRACT(DAYOFWEEK FROM starttime)=7, 
          true, false) is_weekend,
  tripduration as label
FROM
  `04_nyc_bike_sharing.training_table`;
```
在这个第二个模型中，我们添加了一个名为is_weekend的新特征。这个字段是一个IF语句，如果该天是星期日或星期六，则返回true，表示值为1和7；否则，为false。

如果我们检查这个新的 BigQuery ML 模型的平均绝对误差，我们可以注意到我们通过一个值为 6.7784 的值略微提高了我们模型的性能。
由于我们通过添加更多特征获得了一些改进，让我们尝试将客户的年龄作为新的参数包含到我们的 ML 模型中：
```
CREATE OR REPLACE MODEL 
  `04_nyc_bike_sharing.trip_duration_by_stations_day_age`
OPTIONS
  (model_type='linear_reg') AS
SELECT
  start_station_name,
  end_station_name,
  IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR
        EXTRACT(DAYOFWEEK FROM starttime)=7, 
        true, false) is_weekend,
  EXTRACT(YEAR FROM starttime)-birth_year as age,
  tripduration as label
FROM
  `04_nyc_bike_sharing.training_table`;
```
与之前的模型相比，我们添加了新的 age 列，该列是 starttime 年份与客户出生年份之差。

执行查询语句后，我们将看到新的 age 特征并没有提高我们的 ML 模型的性能。这是因为平均绝对误差为 6.9508。这个值与我们的第一次尝试相比有所改善，但比第二次尝试要差。

在本节中，我们在尝试使用数据集的不同特征创建不同的 ML 模型。接下来，我们将继续使用 trip_duration_by_stations_and_day 模型，该模型在训练阶段在平均绝对误差方面实现了最佳性能。

现在，让我们学习如何开始评估阶段。

评估线性回归模型

对于我们 BigQuery ML 模型的评估阶段，我们将使用 ML.EVALUATE 函数以及我们明确创建的用于存储评估记录的表。这些记录与训练阶段使用的行完全分开。

让我们执行以下查询以评估我们的 ML 模型在评估表上的性能：

SELECT
  *
FROM
  ML.EVALUATE(MODEL `04_nyc_bike_sharing.trip_duration_by_stations_and_day`,
    (
    SELECT
          start_station_name,
          end_station_name,
          IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR 
                EXTRACT(DAYOFWEEK FROM starttime)=7, 
                true, false) is_weekend,
          tripduration as label
    FROM
          `04_nyc_bike_sharing.evaluation_table`));

SELECT 语句提取了 ML.EVALUATE 函数返回的所有字段。评估函数应用于 04_nyc_bike_sharing.trip_duration_by_stations_and_day` 模型以及从 evaluation_table 表中提取的行。

最内部的 SELECT 提取了用于训练 ML 模型的相同字段，作为应用相同转换的特征，例如在 is_weekend 字段上，该字段使用与训练阶段相同的逻辑计算。

查询结果显示平均绝对误差非常接近 7 分钟，这与训练阶段实现的 6.7784 的值相似。因此，我们可以说 ML 模型在不同于训练数据集的数据集上保持了其性能。我们可以说该模型没有受到过拟合的影响。

在下面的屏幕截图中，您可以查看由评估查询提取的性能指标：

![Figure 4.12 – 评估函数的查询结果显示了 ML 关键性能指标]

在评估表上计算的性能

图 4.12 – 评估函数的查询结果显示了在评估表上计算的 ML 关键性能指标

现在我们已经训练了模型，并且对评估阶段的成果也感到满意，让我们学习如何将我们的机器学习模型应用于其他记录并获取预测。

利用线性回归模型

要使用我们的 BigQuery ML 模型，我们将使用 ML.PREDICT 函数以及我们明确创建的用于存储尚未使用的记录的表。

以下查询将使用 prediction_table 中的数据预测标签：

SELECT
   tripduration as actual_duration,
   predicted_label as predicted_duration,
   ABS(tripduration - predicted_label) difference_in_min
FROM
  ML.PREDICT(MODEL `04_nyc_bike_sharing.trip_duration_by_stations_and_day`,
    (
    SELECT
          start_station_name,
          end_station_name,
          IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR 
                EXTRACT(DAYOFWEEK FROM starttime)=7, 
                true, false) is_weekend,
          tripduration
    FROM
          `04_nyc_bike_sharing.prediction_table`
    ))
    order by  difference_in_min asc;

查询语句由 SELECT 关键字组成，它提取了租赁的实际和预测持续时间。它计算分钟差异并按分钟差异的最小值到最大值对结果进行排序。为了计算差异，我们使用了 ABS 函数，该函数提取数字的绝对值。

ML.PREDICT 函数应用于 SELECT 语句，该语句从 prediction_table 中提取特征和实际持续时间。最后一个字段仅用于与预测值进行比较，并不用于运行机器学习模型。

在下面的屏幕截图中，您可以查看查询执行的结果：

图 4.13 – PREDICT 函数的查询结果显示了实际和预测的持续时间。

现在我们已经应用了我们的模型，让我们制定一些最终考虑事项，并向我们的经理们提供关于预测自行车租赁行程持续时间的可能性的答案。

提炼业务结论

在本节中，我们将使用应用我们的机器学习模型得到的结果制定一些最终考虑事项。

通过在先前的查询中添加一个父 SELECT COUNT 语句，我们可以确定有多少预测值与实际值相差小于 15 分钟。

让我们执行以下查询来计算行程持续时间预测与实际值相差多远的情况：

SELECT COUNT (*)
FROM (
SELECT
   tripduration as actual_duration,
   predicted_label as predicted_duration,
   ABS(tripduration - predicted_label) difference_in_min
FROM
  ML.PREDICT(MODEL `04_nyc_bike_sharing.trip_duration_by_stations_and_day`,
    (
    SELECT
          start_station_name,
          end_station_name,
          IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR 
                EXTRACT(DAYOFWEEK FROM starttime)=7, 
                true, false) is_weekend,
          tripduration
    FROM
          `04_nyc_bike_sharing.prediction_table`
    ))
    order by difference_in_min asc) where difference_in_min<=15;

SELECT COUNT 查询的结果返回了 1,548,370 个预测值，预测值与实际值之间的差异小于 15 分钟。

考虑到 prediction_table 表的总大小为 1,728,078，我们可以这样说，在 89.6% 的情况下，我们的机器学习模型能够预测行程持续时间，误差在 15 分钟以内。

由于我们之前表达的原因，我们可以建议管理层从新的按需和按次付费定价模型开始，采用季度费用。采用这种策略，当客户在特定的一天从起始站取车并在移动应用程序上指定目的地时，我们的模型将能够预测行程的确切费用，平均绝对误差约为 7 分钟。该应用程序将提供 89.6% 的准确价格估计给我们的客户。

摘要

在本章中，我们基于现实生活中的场景构建了我们的第一个机器学习用例。在简要介绍用例之后，我们发现了线性回归是什么以及它如何用于预测数值。

在实际开发机器学习模型之前，我们了解到，对数据有清晰的理解并检查其质量是获得有效机器学习模型的基本要求。为了从坚实的基础开始，我们利用了 BigQuery 公共数据集，该数据集收集了有关纽约市自行车共享服务所有租赁信息。

在训练模型时，我们使用了不同的特征来了解哪些变量与构建我们的 BigQuery ML 模型相关。

然后，我们选择了一个机器学习模型继续到评估阶段。在这个阶段，我们使用了 BigQuery 评估函数来验证机器学习模型是否也能在训练数据集之外的新的行上有效工作。

最后，我们将我们的机器学习模型应用于第三个记录子集，以预测每辆自行车租赁的时长。我们通过利用用户选择的起始站和结束站以及行程发生的星期几来完成这项工作。

我们还计算出其中 89%的时长与实际行程时长相差不到 15 分钟。因此，我们可以得出结论，如果公司对我们的新按次付费服务实施季度票价，我们可以为我们的客户提供良好的用户体验。

在下一章中，我们将探讨二元逻辑回归以及如何使用 BigQuery ML 来预测布尔变量。

进一步阅读

纽约市自行车共享公共数据集：console.cloud.google.com/marketplace/product/city-of-new-york/nyc-citi-bike
BigQuery ML 创建模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create
BigQuery ML 评估模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
BigQuery ML 预测：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-predict
BigQuery ML 线性回归示例：cloud.google.com/bigquery-ml/docs/bigqueryml-natality

第五章：使用二元逻辑回归预测布尔值

二元逻辑回归是最广泛使用的机器学习（ML）算法之一，用于预测未来事件和行为分类。它在不同的行业和环境中都有应用。可以使用这种技术预测的变量包括购买产品的倾向以及特定服务获得正面或负面客户反馈的概率。

大多数数字原生公司以订阅模式提供他们的服务。在流媒体视频服务、电信运营商和付费电视中，二元逻辑回归技术被广泛用于预测客户流失的可能性。预测这类信息对于针对营销活动和针对购买意愿最高、能增加收入的客户提供的特别优惠至关重要。

在本章中，我们将看到实施二元逻辑回归模型所需的所有阶段，利用 BigQuery ML。

使用 BigQuery ML SQL 语言，我们将探讨以下主题：

介绍业务场景
发现二元逻辑回归
探索和理解数据集
训练二元逻辑回归模型
评估二元逻辑回归模型
使用二元逻辑回归模型
提出业务结论

技术要求

本章需要访问网络浏览器，并能够利用以下功能：

一个 GCP 账户以访问 Google Cloud Console
一个 GCP 项目来托管 BigQuery 数据集

现在我们已经准备好了技术要求，让我们深入分析和发展我们的 BigQuery ML 二元逻辑回归模型。

查看以下视频，以查看代码的实际应用：bit.ly/2QXCGHM

介绍业务场景

在本节中，我们将介绍将使用二元逻辑回归来解决的问题的业务场景。

让我们以一个例子为例，你是一位对机器学习充满热情的出租车司机。你现在在芝加哥工作，你的目标是为你所有的同事提供一个额外的工具，以了解从你的顾客那里获得小费的概率。

获取顾客的提示对出租车司机来说非常重要，这有助于增加他们的收入。预测获得小费的可能性可能对以下情况很有用，例如知道何时为特定客户群体预留特别温和的待遇。

在以下照片中，你可以看到芝加哥的一辆出租车：

图 5.1 – 芝加哥的出租车

芝加哥市自 2013 年以来收集了大多数出租车行程的信息。这个数据集可在 BigQuery 公共数据集市场（console.cloud.google.com/marketplace/details/city-of-chicago-public-data/chicago-taxi-trips）中找到，并且可以轻松访问和使用。

你的目标是利用关于出租车行程的可用信息，例如支付类型、行驶里程、车费以及出租车公司的名称，来预测出租车司机在出租车行程结束时是否会收到小费。

既然我们已经解释并理解了业务场景，让我们看看我们可以用来预测特定事件是否会发生的人工智能技术。

发现二元逻辑回归

在本节中，我们将学习什么是二元逻辑回归，并了解可以使用此机器学习算法解决的问题用例。

逻辑回归是一种分类机器学习技术，可以用来预测分类变量。当要预测的变量是二元且只能假设两个值时（例如，真或假、是或否、1 或 0），我们可以应用二元逻辑回归。

为了预测两个标签中的一个，此机器学习算法计算两种不同结果的可能性，并允许我们选择一个概率阈值以获得二元变量的最终分类。

由于这是一个基于回归技术的算法，标签的预测基于一组称为特征的独立变量，这些变量用于预测称为标签的因变量。

这种人工智能技术可以用于回答不同行业的相关业务问题，例如以下问题：

这个客户会买我的产品吗？
我的客户对我的服务满意吗？
我的客户在接下来的几个月内会取消我的服务吗？
这个学生会通过下一场考试吗？
这个人下一年会患上糖尿病吗？

在我们的业务场景中，可以通过二元逻辑回归预测出租车行程结束时获得小费的可能性。实际上，我们感兴趣的是预测某个事件是否会发生。如果出租车司机将获得小费，二元分类变量将被赋予值 1，否则为 0。

训练二元逻辑回归模型意味着尝试找到可以用于输入变量（称为特征）和二元输出变量（称为标签）之间方程的系数值。

训练完成后，我们将利用混淆矩阵来评估我们的二元逻辑回归模型的表现。在这个矩阵中，行表示标签的预测值，而列用于存储实际值。

以下图表示了一个用于评估二元逻辑回归性能的混淆矩阵：

![图 5.2 – 混淆矩阵

![图 5.3 – chicago_taxi_trips 数据集只包含一个表：taxi_trips]

图 5.2 – 混淆矩阵

此矩阵使我们能够可视化机器学习算法的性能，比较正确预测与错误预测。

从混淆矩阵中将要展示的数字中，我们可以提取出逻辑回归模型的基本性能指标：曲线下面积（AUC）和接收者操作特征（ROC）。ROC曲线帮助我们测量具有各种阈值的分类场景的性能。基本上，它告诉我们我们的机器学习模型在预测正确类别方面的能力。

ROC曲线是使用以下两个参数绘制的图表：

假正率位于横坐标轴上。此参数是假正例数量与假正例和真反例之和的比率。
真正率位于纵坐标轴上。此参数也称为模型的召回率。它是真正例与真正例和假反例之和的比率。

如果曲线下面积，称为AUC，很高且接近 1，则模型更有可能能够预测正确的标签。

我们已经学习了二元逻辑回归的基础知识；现在是时候看看我们将用它来构建机器学习模型的数据集了。

探索和理解数据集

如我们在第四章，“使用线性回归预测数值”中学习的，在深入机器学习实现之前，分析我们用例中的可用数据是必要的。我们需要首先对可用于我们业务场景的数据有一个清晰的理解。

理解数据

要开始探索数据，我们需要做以下事情：

登录 Google Cloud 控制台，并通过导航菜单访问BigQuery用户界面。
在我们第二章，“设置您的 GCP 和 BigQuery 环境”中创建的项目中创建一个新的数据集。对于此用例，我们将使用默认选项创建名为05_chicago_taxi的数据集。
打开bigquery-public-data GCP 项目，该项目托管所有 BigQuery 公共数据集，浏览项目直到找到chicago_taxi_trips数据集。在这个公共数据集中，我们只能看到一个 BigQuery 表：taxi_trips。此表包含关于在芝加哥市发生的出租车行程的所有信息，我们将使用它来训练和测试我们的机器学习模型：![图 5.3 – The chicago_taxi_trips 数据集只包含一个表：taxi_trips

![图 5.3 – chicago_taxi_trips 数据集只包含一个表：taxi_trips]

图 5.3 – The chicago_taxi_trips 数据集只包含一个表：taxi_trips
让我们点击名为tips的列，该列以数值FLOAT格式表示。显然，这可能会看起来像一个问题，因为我们的机器学习模型只能预测布尔值。这种情况可以通过应用以下规则轻松克服：如果tips的值大于 0，则标签为 1，否则为 0。

我们可以利用表中的所有其他列作为我们机器学习模型的特征。出租车行程的持续时间可能是一个好的特征，因为在较长的行程中，出租车司机有更多时间熟悉顾客，而短途行程只有几分钟。接车和下车地点可能会影响小费，因为我们可以想象，一些地区比其他地区更有利可图。例如，一个城市中有很多商业和大型公司办公区的地区可能会增加得到小费的可能性。

用于支付出租车费用的支付类型是我们分析中的另一个重要因素。当你需要用电子支付方式支付给出租车司机时，通常通过在销售点（POS）设备上按一个按钮来给小费会更简单。

此外，出租车公司的名字也可能是需要考虑的另一个重要特征。一些出租车公司可以在服务、司机的专业性和车辆的舒适性方面为顾客提供更好的体验。所有这些因素都可能影响顾客给出租车司机小费的决定。

从模式的角度来看，这个表格包含了许多有用的信息，这些信息可以用来开发我们的二元逻辑回归模型。让我们继续分析，深化我们对数据的理解。
作为下一步，让我们看看表中记录的数量以及它们是否足够用于我们的目的。在详细信息标签页中，我们可以注意到该表包含超过 1.94 亿条记录。我们可以有信心用这么多的数据来构建我们的机器学习模型：

图 5.4 – taxi_trips 表上的详细信息标签页显示了记录数以及以 GB 为单位的表格大小
现在，让我们看看taxi_trips表中的实际数据：
```
SELECT *
FROM
  `bigquery-public-data.chicago_taxi_trips.taxi_trips`
LIMIT 10;
```
查询显示了表中的所有字段，并过滤出前 10 行。使用LIMIT 10子句来限制结果集中的记录数，并从表中返回随机选择的行。
在预览了表格内容之后，我们可以分析我们数据集的时间范围：
```
SELECT MIN(trip_start_timestamp),  MAX(trip_start_timestamp)
FROM
  `bigquery-public-data.chicago_taxi_trips.taxi_trips`;
```
查询提取了trip_start_timestamp字段的最低值和最高值，以便清楚地了解数据收集的时期。

在下面的屏幕截图中，您可以查看查询执行的结果：

图 5.5 – 查询返回 trip_start_timestamp 字段的最小值和最大值

在撰写本书时，最小值是 2013 年 1 月 1 日，而最大值是 2020 年 10 月 1 日。
然后，我们可以对作为我们的标签基础的 tips 字段进行数据质量检查。事实上，如果 tips 列大于 0，我们可以假设出租车司机收到了顾客的小费：
```
SELECT COUNT(*)
FROM
  `bigquery-public-data.chicago_taxi_trips.taxi_trips`
WHERE
        tips IS NULL;
```
在下面的屏幕截图中，您可以看到查询的结果：

图 5.6 – 查询返回 4,784 条 tips 字段为空的记录

执行 SELECT COUNT(*) 查询，我们可以注意到有 4,784 条记录的 tips 字段为空。在创建 ML 模型时，我们将考虑这一方面，过滤掉这些行。

在本节中，我们已经分析了我们可以利用来构建我们的 ML 模型的数据集，因此现在让我们开始将其分割成三个不同的集合：训练、评估和分类。

数据集分段

在实现我们的二元逻辑回归模型之前，让我们根据 ML 开发的主要阶段来分割我们的数据集：训练、评估和使用：

要了解数据如何在年份和月份之间分布，我们可以使用以下查询语句：
```
SELECT     EXTRACT (YEAR FROM trip_start_timestamp) year,
           EXTRACT (MONTH FROM trip_start_timestamp) month,
           COUNT(*) total
FROM
          `bigquery-public-data.chicago_taxi_trips.taxi_trips`
WHERE 
           tips IS NOT NULL AND
           trip_seconds IS NOT NULL AND
           trip_miles IS NOT NULL AND
           fare IS NOT NULL AND
           tolls IS NOT NULL AND
           pickup_location IS NOT NULL AND
           dropoff_location IS NOT NULL AND
           pickup_latitude IS NOT NULL AND
           pickup_longitude IS NOT NULL AND
           dropoff_latitude IS NOT NULL AND
           dropoff_longitude IS NOT NULL AND
           company IS NOT NULL AND
           trip_miles > 1 AND
           trip_seconds > 180
GROUP BY
          year, month
ORDER BY
           year, month ASC;
```
SELECT 语句提取了关于出租车行程发生的年份和月份的信息，并为每个月计算了总行程数。这种聚合是通过查询末尾的 GROUP BY 子句实现的。

查询从 taxi_trips 表中提取记录，但应用了一些重要的过滤器。所有 tips 字段为空的记录以及所有潜在特征等于 NULL 的行都被排除。

为了排除异常值和可能的错误测量，我们决定只保留持续时间超过 3 分钟且超过一英里的出租车行程。

多亏了 ORDER BY 子句，结果按升序排列：

图 5.7 – 查询返回 taxi_trips 表中记录的分布

关注最近的几个月，我们可以立即注意到 2020 年 4 月的数字下降。这种突然的下降可能是由于为管理 COVID-19 大流行而引入的限制所导致的。为了避免任何事件对我们分析的影响，让我们只关注 2019 年。我们将使用从 2019 年 1 月到 2019 年 10 月的时间框架来分割我们的数据集。

让我们创建一个包含将要用于训练我们的 BigQuery ML 模型的行的表。对于此用例，我们将仅选择从 2019 年 1 月到 2019 年 8 月（包括）发生的出租车行程：

CREATE OR REPLACE TABLE `05_chicago_taxi.training_table` AS
    SELECT *
    FROM
          `bigquery-public-data.chicago_taxi_trips.taxi_trips`
    WHERE
           tips IS NOT NULL AND
           trip_seconds IS NOT NULL AND
           trip_miles IS NOT NULL AND
           fare IS NOT NULL AND
           tolls IS NOT NULL AND
           pickup_location IS NOT NULL AND
           dropoff_location IS NOT NULL AND
           pickup_latitude IS NOT NULL AND
           pickup_longitude IS NOT NULL AND
           dropoff_latitude IS NOT NULL AND
           dropoff_longitude IS NOT NULL AND
           company IS NOT NULL AND
           trip_miles > 1 AND
           trip_seconds > 180 AND
           EXTRACT (YEAR FROM trip_start_timestamp) = 2019 AND
           (EXTRACT (MONTH FROM trip_start_timestamp) >=1 AND EXTRACT (MONTH FROM trip_start_timestamp)<=8);

从CREATE TABLE语句中，我们可以注意到查询过滤掉了所有具有空特征和标签的行，这些特征和标签在机器学习模型的实现过程中可能会引起问题。

之后，我们创建另一个表格，专门用于评估我们的机器学习模型的记录：

CREATE OR REPLACE TABLE `05_chicago_taxi.evaluation_table` AS
    SELECT *
    FROM
          `bigquery-public-data.chicago_taxi_trips.taxi_trips`
    WHERE
           tips IS NOT NULL AND
           trip_seconds IS NOT NULL AND
           trip_miles IS NOT NULL AND
           fare IS NOT NULL AND
           tolls IS NOT NULL AND
           pickup_location IS NOT NULL AND
           dropoff_location IS NOT NULL AND
           pickup_latitude IS NOT NULL AND
           pickup_longitude IS NOT NULL AND
           dropoff_latitude IS NOT NULL AND
           dropoff_longitude IS NOT NULL AND
           company IS NOT NULL AND
           trip_miles > 1 AND
           trip_seconds > 180 AND
           EXTRACT (YEAR FROM trip_start_timestamp) = 2019 AND
           EXTRACT (MONTH FROM trip_start_timestamp) = 09;

与包含训练数据的表格相比，唯一的区别在于我们选择的月份来创建这个表格。在这种情况下，我们选择包含与 2019 年 9 月相关的记录。

最后的准备步骤是基于创建我们将用于测试二元逻辑回归模型的表格。让我们根据以下 SQL 语句创建classification_table：

CREATE OR REPLACE TABLE `05_chicago_taxi.classification_table` AS
    SELECT *
    FROM
          `bigquery-public-data.chicago_taxi_trips.taxi_trips`
    WHERE
           tips IS NOT NULL AND
           trip_seconds IS NOT NULL AND
           trip_miles IS NOT NULL AND
           fare IS NOT NULL AND
           tolls IS NOT NULL AND
           pickup_location IS NOT NULL AND
           dropoff_location IS NOT NULL AND
           pickup_latitude IS NOT NULL AND
           pickup_longitude IS NOT NULL AND
           dropoff_latitude IS NOT NULL AND
           dropoff_longitude IS NOT NULL AND
           company IS NOT NULL AND
           trip_miles > 1 AND
           trip_seconds > 180 AND
           EXTRACT (YEAR FROM trip_start_timestamp) = 2019 AND
           EXTRACT (MONTH FROM trip_start_timestamp) = 10;

多亏了我们在查询中应用的筛选和过滤器，我们的集合将只包含与 2019 年 10 月相关的记录。我们还可以注意到，所有其他过滤器在三个数据集（训练、评估和分类）中保持不变且一致。

现在我们已经将数据集分为三个部分，让我们开始实际训练二元逻辑回归机器学习模型。

训练二元逻辑回归模型

正如我们在第四章中已经做的那样，使用线性回归预测数值值，我们将采用增量方法来尝试在每次尝试中提高我们的机器学习模型的表现：

让我们开始训练我们的第一个机器学习模型，binary_classification_version_1：
```
CREATE OR REPLACE MODEL `05_chicago_taxi.binary_classification_version_1`
OPTIONS
  (model_type='logistic_reg', labels = ['will_get_tip']) AS
    SELECT
        trip_seconds,
        IF(tips>0,1,0) AS will_get_tip
    FROM  `05_chicago_taxi.training_table`;
```
在这个 BigQuery ML 语句中，我们可以看到用于开始模型训练的CREATE OR REPLACE MODEL关键字。这些关键字后面跟着机器学习模型的标识符。在标识符之后，我们可以注意到OPTIONS子句。作为我们的选项，我们选择使用logistic_reg算法来训练模型，并使用will_get_tip字段作为目标标签。

SELECT语句指出，如果tips字段的值大于 0，则will_get_tip标签的值为1，否则为0。在SELECT语句中，我们还包含了我们第一次尝试使用的唯一特征：trip_seconds。这个特征代表出租车行程的持续时间（以秒为单位）。

最后，SELECT语句基于我们创建的用于训练模型的表格：05_chicago_taxi.training_table。
训练结束后，我们可以从 BigQuery 导航菜单中访问机器学习模型，查看模型的表现。选择评估选项卡，我们可以看到ROC AUC值。在这种情况下，我们可以看到我们没有取得很好的结果，因为它没有接近 1；它是0.5696：

图 5.8 – 评估选项卡显示了与训练的机器学习模型相关的 ROC AUC 值

在同一个选项卡中，我们还可以看到 ROC 曲线：

图 5.9 – 在评估标签页中，也可以图形化分析 ROC 曲线并看到 ROC 曲线下的蓝色区域

如前图所示，表示真正例与假正例之间比率的 ROC 曲线并没有接近 1。曲线下的蓝色区域大约占整个正方形的 50%。

如下截图所示，我们还可以在同一标签页中利用混淆矩阵来根据不同的阈值实验机器学习模型的输出：

图 5.10 – 在评估标签页中，也可以查看分类模型的混淆矩阵
让我们尝试通过添加有助于预测小费概率的特征来改进我们的机器学习模型。我们将引入出租车行程的票价、行程中支付的费用以及出租车公司的名称作为新的特征：
```
CREATE OR REPLACE MODEL `05_chicago_taxi.binary_classification_version_2`
OPTIONS
  (model_type='logistic_reg', labels = ['will_get_tip']) AS
    SELECT
        trip_seconds,
        fare,
        tolls,
        company,
        IF(tips>0,1,0) AS will_get_tip
    FROM  `05_chicago_taxi.training_table`;
```
CREATE OR REPLACE MODEL部分与之前的一个类似，但包括了之前提到的新的功能。尽管增加了新的字段，但在ROC AUC方面的改进并不显著。实际上，通过这次尝试，我们已经达到了0.5902的值。
是时候介绍一个可能对我们机器学习模型开发极为有帮助的特征了。下一个机器学习模型binary_classification_version_3将引入客户支付出租车司机的支付类型：
```
CREATE OR REPLACE MODEL `05_chicago_taxi.binary_classification_version_3`
OPTIONS
  (model_type='logistic_reg', labels = ['will_get_tip']) AS
    SELECT
        trip_seconds,
        fare,
        tolls,
        company,
        payment_type,
        IF(tips>0,1,0) AS will_get_tip
    FROM  `05_chicago_taxi.training_table`; 
```
在训练这个机器学习模型之后，我们可以立即注意到ROC AUC值的巨大提升。将支付方式作为特征添加到我们的模型中，我们达到了0.9809的值。这非常接近 1，代表了我们二元逻辑回归模型性能的显著提升。
在前一个代码块中，我们使用binary_classification_version_3机器学习模型所取得的结果已经是一个很好的结果了。让我们看看是否可以通过利用出租车行程的接车和下车位置信息来进一步改进我们的分类模型：
```
CREATE OR REPLACE MODEL `05_chicago_taxi.binary_classification_version_4`
OPTIONS
  (model_type='logistic_reg', labels = ['will_get_tip']) AS
    SELECT
        trip_seconds,
        fare,
        tolls,
        company,
        payment_type,
        pickup_location,
        dropoff_location,
        IF(tips>0,1,0) AS will_get_tip
    FROM  `05_chicago_taxi.training_table`; 
```
查询语句与其他训练语句非常相似，但引入了两个额外的特征：pickup_location和dropoff_location。这两个字段代表出租车行程开始和结束的区域。

在训练机器学习模型之后，我们可以立即欣赏到我们进一步提高了分类模型的性能。这从ROC AUC值中可以清楚地看出，其值为0.9827。

通过查看混淆矩阵，我们可以选择最佳阈值，以在真正例和真负例预测之间取得正确的平衡。

阈值值影响真正例率和假正例率之间的比率。找到最佳阈值意味着找到一个值，以最大化真正例率并最小化假正例率。

在以下屏幕截图中，您可以看到混淆矩阵和 正类阈值 滑块：

![Figure 5.11 – 混淆矩阵显示了在预测标签与实际标签方面的出色表现预测标签与实际标签的对比

图 5.11 – 混淆矩阵显示了在预测标签与实际标签方面的出色表现

所有其他关键性能指标，如精确率、召回率和准确率，都非常高，接近 1 的最大值。

从图形角度来看，我们可以欣赏到我们 ML 模型的优秀质量。事实上，ROC 曲线下方的蓝色区域非常接近 1，几乎覆盖了整个正方形的面积。以下截图显示了最后一个 ML 模型的 ROC 曲线，并显示我们的 ML 模型已经取得了优异的结果：

![Figure 5.12 – ROC 曲线下方的面积非常接近 1，并且几乎填满了整个正方形

图 5.12 – ROC 曲线下方的面积非常接近 1，并且几乎填满了整个正方形

在本节中，我们利用数据集中可用的特征训练了一些二元逻辑回归 ML 模型。为了进行评估阶段，我们选择使用表现最佳的 binary_classification_version_4 模型。现在，让我们看看如何开始评估阶段。

评估二元逻辑回归模型

为了评估我们的 BigQuery ML 模型，我们将使用 ML.EVALUATE 函数和专门创建的作为评估数据集的表。

以下查询将告诉我们模型是否过度拟合，或者是否也能在新数据上表现良好：

SELECT
  roc_auc,
  CASE
    WHEN roc_auc > .9 THEN 'EXCELLENT'
    WHEN roc_auc > .8 THEN 'VERY GOOD'
    WHEN roc_auc > .7 THEN 'GOOD'
    WHEN roc_auc > .6 THEN 'FINE'
    WHEN roc_auc > .5 THEN 'NEEDS IMPROVEMENTS'
  ELSE
  'POOR'
END
  AS model_quality
FROM 
  ML.EVALUATE(MODEL `05_chicago_taxi.binary_classification_version_5`,
    (
    SELECT
        trip_seconds,
        fare,
        tolls,
        company,
        payment_type,
        pickup_location,
        dropoff_location,
        IF(tips>0,1,0) AS will_get_tip
     FROM `05_chicago_taxi.evaluation_table`));

SELECT 语句提取了 ML.EVALUATE 函数返回的 roc_auc 值，并提供了对模型质量的清晰描述，从 'POOR' 级别开始，到 'EXCELLENT' 级别，经过一些中间阶段，如 'NEEDS IMPROVEMENTS' 和 'GOOD'。

执行查询，我们可以看到分数非常高，结果是 EXCELLENT：

![Figure 5.13 – 评估阶段返回了我们的 BigQuery ML 模型的优秀质量结果

图 5.13 – 评估阶段返回了我们的 BigQuery ML 模型的优秀质量结果

现在我们已经评估了我们的 ML 模型，让我们看看我们如何将其应用于其他记录以获取预测结果。

使用二元逻辑回归模型

在本节中，我们将使用 ML 模型来预测客户获得小费的概率。

为了测试我们的 BigQuery ML 模型，我们将在 classification_table 表上使用 ML.PREDICT 函数：

SELECT predicted_will_get_tip, predicted_will_get_tip_probs, will_get_tip actual
FROM
  ML.PREDICT(MODEL`05_chicago_taxi.binary_classification_version_5`,
    (
      SELECT
        trip_seconds,
        fare,
        tolls,
        company,
        payment_type,
        pickup_location,
        dropoff_location,
        IF(tips>0,1,0) AS will_get_tip
       FROM `05_chicago_taxi.classification_table`));

查询由一个SELECT语句组成，该语句提取了will_get_tip字段的实际和预测值。如果没有指定，ML.PREDICT将使用值0.5作为默认阈值。

查询的输出显示了以下列：

第一列中的预测标签
第二列和第三列中每个标签的计算概率
从classification_table中提取的实际值作为最后一列

在下面的屏幕截图中，你可以看到查询执行的结果：

![Figure 5.14 – 查询的输出显示了预测标签与实际标签的比较

![img/B16722_05_014.jpg]

图 5.14 – 查询的输出显示了预测标签与实际标签的比较

现在我们已经测试了我们的 BigQuery ML 模型，让我们对根据我们所拥有的出租车行程信息预测客户是否会给出租车司机小费的可能性进行一些最终考虑。

提出业务结论

在本节中，我们将使用我们的机器学习模型，并了解 BigQuery ML 模型能够预测实际结果多少次。

使用默认阈值0.5，让我们看看 ML 模型能够正确识别司机是否会得到小费多少次：

SELECT COUNT(*)
FROM (
      SELECT predicted_will_get_tip, predicted_will_get_tip_probs, will_get_tip actual_tip
      FROM
        ML.PREDICT(MODEL`05_chicago_taxi.binary_classification_version_5`,
          (
            SELECT
              trip_seconds,
              fare,
              tolls,
              company,
              payment_type,
              pickup_location,
              dropoff_location,
              IF(tips>0,1,0) AS will_get_tip
             FROM `05_chicago_taxi.classification_table`)))
WHERE
       predicted_will_get_tip =  actual_tip;

为了计算这个值，我们引入了WHERE子句，仅过滤那些预测值等于实际值的行。

SELECT COUNT返回了 727,462 个预测值，与预测值等于实际值相对应。

在总共 744,058 行中，我们可以说，我们的模型在标准阈值为 0.5 的情况下，在 97.76%的情况下预测了正确的结果。

由于我们利用 BigQuery ML 创建了一个非常有效的二元逻辑回归模型，我们现在有信心向我们的出租车司机提供见解和建议。了解提前得到小费的概率，他们可以根据他们服务的客户得到小费的概率采取不同的行为。

摘要

在本章中，我们实现了一个二元逻辑回归模型。我们基于芝加哥市收集的出租车服务数据介绍了业务场景。之后，我们学习了二元逻辑回归技术如何用于预测二元值。

为了构建一个有效的模型，我们对数据进行详细分析，然后根据我们的需求将数据集分为三个表：一个用于存放训练数据，第二个用于评估，最后一个用于应用我们的分类模型。

在 BigQuery ML 模型的训练阶段，我们根据混淆矩阵和 ROC AUC 值不断改进 ML 模型的性能。

之后，我们在一组新的记录上评估了最佳的机器学习模型，以验证是否存在过拟合，并增加对我们二元逻辑回归模型高质量的好感。

最后，我们将我们的机器学习模型应用于最后一批记录，以预测每次出租车行程结束时客户是否得到小费的可能性。我们发现我们的机器学习模型能够正确预测客户行为在 97%以上的情况下。

在下一章中，我们将介绍多类逻辑回归，并学习如何根据树木的特征将它们分类到不同的物种。

第六章：使用多类逻辑回归对树木进行分类

多类逻辑回归是用于将事件、实体和行为分类到固定数量类别的机器学习（ML）算法。当需要预测实体分类到多个组时，它可用于不同的行业和业务场景。一个典型的分类用例是，根据公司的盈利能力和偏好对公司客户群进行细分，以便针对最有效的营销活动定位正确的客户。

这种技术是二分类逻辑回归的扩展，使我们能够克服两个可能标签的限制，并使适用性扩展到其他可以找到多个类别进行识别的上下文中。

在本章中，我们将看到实现、评估和测试多类逻辑回归模型所需的所有阶段，利用 BigQuery ML。

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

介绍业务场景
发现多类逻辑回归
探索和理解数据集
训练多类逻辑回归模型
评估多类逻辑回归模型
使用多类逻辑回归模型
提炼业务结论

技术要求

本章要求您访问网络浏览器，并具备利用以下功能的能力：

一个 GCP 账户以访问 Google Cloud 控制台
一个用于托管 BigQuery 数据集的 GCP 项目

现在我们已经准备好了技术要求，让我们深入分析和发展我们的 BigQuery ML 逻辑回归模型。

查看以下视频，了解代码的实际应用：bit.ly/3h4w7xG

介绍业务场景

对于这个业务场景，我们可以想象自己是一名纽约市的 ML 专家。在市应执行的所有活动中，对树木进行普查和验证其状况是最耗时的之一。

这些树木分布在新泽西市的不同区域，收集每棵树的信息是由志愿者或纽约市员工手动完成的。信息收集完成后，数据存储在数据库中，并通过 BigQuery 公共数据集公开，以便进行进一步分析(console.cloud.google.com/marketplace/details/city-of-new-york/nyc-tree-census)。

在以下图中，我们可以看到中央公园的一张照片，这是纽约市树木最多的区域之一：

图 6.1 – 纽约市中央公园的树木

为了支持和加速负责分类树木和评估其状况的人员的工作，你们的一位经理可能要求你构建一个机器学习模型。

机器学习模型的目标是根据树木的特征，如位置、大小和健康状况，自动将树木分类到不同的种类。

对于这个用例，我们只需关注城市中最常见的五种树木种类。

现在我们已经简要解释并理解了业务场景，让我们看看我们可以用来将对象或事件分类到多个类别的机器学习技术。

发现多类逻辑回归

在本节中，我们将学习多类逻辑回归的基础知识以及何时可以应用这项技术。

多类逻辑回归是一种分类技术，可以用来将事件、对象、客户或其他实体分类到多个类别。与二元逻辑回归不同，这个机器学习算法可以将输出值分类到超过两个离散类别。

为了预测多个标签中的一个，这个机器学习算法计算每个结果的概率，并选择概率最高的标签。

作为一种回归算法，标签的预测基于一组称为特征的独立变量，这些变量用于预测称为标签的因变量。

这种机器学习技术可以用来回答以下业务问题：

我的客户的评论是中性、正面还是负面？
我的客户属于金、银还是铜等级？
特定客户的流失概率是高、中还是低？
图像识别算法识别的是猫、狗、老鼠还是牛？

在我们的业务场景中，由于树木的种类有限，我们只关注五种，我们可以利用多类逻辑回归。具体来说，我们感兴趣的是根据树木的大小、位置和健康状况特征将其分类到五种种类之一。

训练多类逻辑回归模型意味着尝试找到可以用于输入变量（称为特征）和输出变量（称为标签）之间方程的系数值。

训练完成后，我们将利用混淆矩阵来评估我们的多类逻辑回归模型的表现。在多类逻辑回归中，混淆矩阵由多行和多列组成。

为了评估我们的机器学习模型的表现，我们还将使用曲线下面积（AUC）接收者操作特征（ROC）。

现在我们已经学习了多类逻辑回归的基础知识，是时候看看我们将用于构建机器学习模型的那个数据集了。

探索和理解数据集

正如我们在前面的用例中所做的那样，在深入开发机器学习模型之前，分析可用于解决我们用例的数据是必要的。

我们将首先分析表结构，以便清楚地了解可用于我们业务场景的数据。

理解数据

在本节中，我们将查看数据以了解其结构以及如何用它来构建我们的机器学习模型。

要开始探索数据，我们需要做以下几步：

登录 Google Cloud 控制台，并通过导航菜单访问BigQuery用户界面。
在我们创建的项目下创建一个新的数据集，该项目在第二章，设置您的 GCP 和 BigQuery 环境中提到。对于此用例，我们将使用默认选项创建数据集06_nyc_trees。
打开 GCP 项目new_york_trees。
如以下截图所示，BigQuery 公共数据集包含多个表，用于存储每 10 年收集的数据：

图 6.2 – 纽约市树木公共数据集包含了每 10 年收集的树木普查数据
我们将使用最新的一个：tree_census_2015。这个表包含了 2015 年在纽约市种植并注册的所有树木信息。
让我们在 BigQuery 导航菜单中点击表名tree_census_2015以访问表的架构：

图 6.3 – tree_census_2015 表的结构列出了所有可以作为标签和特征的字段
每个字段都在描述列中有很好的描述。

表中包含表示每种树木物种的科学名称的spc_latin列，该列以STRING形式表示。这个字段将是我们的机器学习模型的标签。

为了对每棵树进行分类，我们可以利用其他字段中的信息。一些列描述了树木的大小。例如，tree_dbh测量树木的直径，stump_diam代表树桩的直径。我们还可以利用关于树木健康状况的信息。我们可以想象，一些物种比其他物种更健壮，更适合纽约市的天气。

其他字段与树木在城市中的位置以及其生活环境的背景关系更为密切。为了训练我们的机器学习模型，我们可以使用树木所在的邮编区域：zip_city。其他一些例子包括包含树木种植区域名称的boroname列，以及代表树木所属地区的nta_name。

我们还可以假设某些物种比其他物种更具侵入性——sidewalk 字段表示树木旁边的人行道是否因树木的根而受损、开裂或抬起。

从架构的角度来看，此表包含大量可用于开发我们的分类模型的有用信息。让我们继续我们的分析，更深入地了解数据。

在本节中，我们已经分析了 tree_census_2015 表的元数据，现在是我们查看实际数据并开始查询的时候了。

检查数据质量

正如我们从之前的用例中已经理解的那样，数据质量对于构建有效的机器学习模型至关重要。在本节中，我们将应用一些数据质量检查，以确定应使用的正确记录：

首先，我们将检查表 tree_census_2015 是否包含 spc_latin 等于 NULL 的记录。这是基本的，因为字段 spc_latin 将用作我们机器学习模型的标签：
```
SELECT  COUNT(*) total
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         spc_latin is NULL;
```
代码块将统计表 bigquery-public-data.new_york_trees.tree_census_2015 中字段 spc_latin 为空的记录数量。

在下面的屏幕截图中，您可以查看查询结果，其中我们得到了超过三千一的结果：

图 6.4 – 查询结果显示某些行包含空标签

因此，在接下来的查询中，我们将排除字段 spc_latin 为空的记录。

仅关注字段 spc_latin 为 NOT NULL 的行，我们可以检查所有其他潜在特征字段上空值的存在：

SELECT  COUNT(*)
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         spc_latin is NOT NULL
         AND (
            zip_city is NULL OR
            tree_dbh is NULL OR
            boroname is NULL OR
            nta_name is NULL OR
            nta_name is NULL OR
            health is NULL OR
            sidewalk is NULL) ;

此外，在这种情况下，查询的结果不是零。事实上，我们可以轻松地识别出三个在 health 和 sidewalk 字段中呈现 NULL 值的记录。

我们将在机器学习模型生命周期的后续阶段过滤这些记录。

现在我们已经对我们的数据集进行了质量检查，并了解了哪些记录应该被过滤，让我们专注于分割我们的数据集，以便只针对树木的五种最频繁出现的物种创建我们的 BigQuery 机器学习模型。

数据集分割

在本节中，我们将准备我们将用于训练、评估和测试我们的机器学习模型的表。

为了我们的目的，我们将从数据集中提取出现频率最高的五种物种。之后，我们将创建用于训练、评估和测试我们的机器学习模型的 BigQuery 表：

首先，我们将使用以下查询仅识别 tree_census_2015 表中的五种最频繁出现的物种：
```
SELECT   spc_latin,
         COUNT(*) total
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         spc_latin is NOT NULL
         AND zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
GROUP BY
         spc_latin
ORDER BY
         total desc
LIMIT 5;
```
SQL 语句使用 GROUP BY spc_latin 子句和 COUNT(*) 操作符计算 tree_census_2015 表中每种物种出现的次数。

查询按照total字段（包含COUNT的结果）的值以降序排列记录，最后，查询的结果集通过查询末尾的LIMIT 5子句限制为结果集的前五条记录。

SQL 语句基于 BigQuery 公共表tree_census_2015，经过我们在前面的检查数据质量部分中确定的数据质量检查适当过滤。

在下面的屏幕截图中，我们可以看到查询结果和我们的数据集中最常见的树木物种：

图 6.5 – 查询的结果显示了纽约市最常见的树木

从查询结果中，我们可以轻松地读取从最常见到最不常见的树木的拉丁学名。

由于我们将在接下来的 SQL 查询中使用这五种物种的子集，我们可以在我们的SELECT语句的开头添加一个CREATE TABLE语句，以便将结果物化到top5_species表中：

CREATE OR REPLACE TABLE `06_nyc_trees.top5_species` AS
      SELECT   spc_latin,
         COUNT(*) total
      FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
      WHERE
               spc_latin is NOT NULL
               AND zip_city is NOT NULL
               AND tree_dbh is NOT NULL
               AND boroname is NOT NULL
               AND nta_name is NOT NULL
               AND health is NOT NULL
               AND sidewalk is NOT NULL
      GROUP BY
               spc_latin
      ORDER BY
               total desc
      LIMIT 5;

通过执行查询，我们将得到创建一个新表的创建，该表仅包含两个字段和五条记录。spc_latin代表树木的物种，而total计算每个物种在原始数据集中的出现次数。

现在，我们可以利用top5_species表来过滤仅关注物种，并创建训练表：
```
CREATE OR REPLACE TABLE `06_nyc_trees.training_table` AS 
SELECT  *
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
         AND spc_latin in 
         (SELECT spc_latin from  `06_nyc_trees.top5_species`)
         AND MOD(tree_id,11)<=8;
```
查询通过SELECT *语句创建一个包含原始数据集中所有列的表。它应用了所有必要的过滤器，以获取spc_latin标签的非空值以及所有其他潜在特征。

使用IN子句，training_table将只包含与数据集中最频繁的五种物种相关的记录。

查询的最后一条语句，带有MOD(tree_id,11)<=8子句，使我们能够只从整个记录集中选择 80%的记录。MOD代表模运算，返回tree_id除以 11 的余数。

使用类似的方法，我们可以创建用于评估我们的机器学习模型的表：

CREATE OR REPLACE TABLE `06_nyc_trees.evaluation_table` AS 
SELECT  *
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
         AND spc_latin in 
         (SELECT spc_latin from `06_nyc_trees.top5_species`) 
         AND MOD(tree_id,11)=9;

对于evaluation_table，我们将通过MOD(tree_id,11)=9过滤器选择仅 10%的记录。

最后，我们将执行以下 SQL 语句以创建用于应用我们的多类分类模型的表：

CREATE OR REPLACE TABLE `06_nyc_trees.classification_table` AS 
SELECT  *
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
         AND spc_latin in 
         (SELECT spc_latin from `06_nyc_trees.top5_species`) 
         AND MOD(tree_id,11)=10;

classification_table与数据集的前几部分非常相似，但多亏了MOD函数，它将包含数据集剩余的 10%。

在本节中，我们分析了包含有关纽约市树木信息的new_york_trees数据集。我们对数据进行了一些数据质量检查，以排除空值。然后，我们分割了数据，重点关注表中出现的五种最常见的物种。现在我们已经完成了准备工作，是时候继续前进并开始训练我们的 BigQuery ML 模型了。

训练多类逻辑回归模型

现在我们已经清楚地理解了数据结构，并且将其分割成多个表格以支持 ML 模型生命周期的不同阶段，让我们专注于我们多类逻辑回归模型的训练。我们将执行 SQL 查询来创建我们的多类逻辑回归模型：

让我们开始创建我们 ML 模型的第一版本：
```
CREATE OR REPLACE MODEL `06_nyc_trees.classification_model_version_1`
OPTIONS
  ( model_type='LOGISTIC_REG',
    auto_class_weights=TRUE
  ) AS
SELECT
  zip_city,
  tree_dbh,
  spc_latin as label
FROM
  `06_nyc_trees.training_table` ;
```
创建classification_model_version_1模型所使用的查询仅基于两个特征：邮编区域和树木直径。

SQL 语句以关键字CREATE OR REPLACE MODEL开始，用于运行训练，后面跟着OPTIONS子句。在选项中，我们可以指定模型类型等于LOGISTIC_REG和auto_class_weights=TRUE。这个选项在我们面对不平衡的训练数据集，某些标签出现频率高于其他标签时尤其有用。在我们的案例中，最常见的物种的出现次数是第五个物种的两倍以上。因此，我们应用了这种调整。

重要提示

BigQuery ML 语法在二元逻辑回归和多类逻辑回归之间没有区别。在两种情况下，BigQuery ML 模型类型都是LOGISTIC_REG。差异是由训练数据集列标签中出现的不同值的数量引起的。如果标签只包含两个值，BigQuery ML 将训练二元逻辑回归。如果标签包含超过两个不同值，模型将作为多类逻辑回归进行训练。
训练执行后，我们可以通过点击导航菜单中的classification_model_version_1并选择评估选项卡来访问我们第一个 ML 模型的信息。

以下截图展示了我们第一次尝试的关键性能指标：

![Figure 6.6 – The Evaluation tab shows the performance metrics related

到选定的 BigQuery ML 模型

![img/B16722_06_006.jpg]

Figure 6.6 – The Evaluation tab shows the performance metrics related to the selected BigQuery ML model

为了了解我们 ML 模型的有效性，我们可以查看ROC AUC值为0.7383。

通过在评估选项卡中用鼠标向下滚动，我们可以查看我们多类逻辑回归模型的混淆矩阵。

在以下图中，混淆矩阵显示了训练数据集中预测和实际标签的百分比：

图 6.7 – 评估选项卡显示了与所选 BigQuery ML 模型相关的混淆矩阵

通过查看混淆矩阵，我们可以直观地注意到，我们的机器学习模型在某些物种上表现相当好，但在其他物种上表现非常差。例如，当实际标签是Quercus palustris时，在 40%的情况下，机器学习模型建议的是不同的物种：Platanus x acerifolia。
让我们尝试通过以下 BigQuery ML SQL 语句添加新特征来改进我们的模型：
```
CREATE OR REPLACE MODEL `06_nyc_trees.classification_model_version_2`
OPTIONS
  ( model_type='LOGISTIC_REG',
    auto_class_weights=TRUE
  ) AS
SELECT
  zip_city,
  tree_dbh,
  boroname,
  nta_name,
  spc_latin as label
FROM
  `06_nyc_trees.training_table` ;
```
与第一次尝试相比，我们在模型的训练中加入了额外的特征。实际上，我们将boroname字段和nta_name中包含的区名添加到了特征列表中。

执行 SQL 语句后，让我们访问新模型的评估选项卡，看看我们是否提高了其性能。查看ROC AUC值为0.7667，我们可以看到我们模型性能的轻微提升。
作为最后的尝试，我们将通过添加额外的特征来丰富我们的机器学习模型。新字段与树木的健康状况和根的大小相关：
```
CREATE OR REPLACE MODEL `06_nyc_trees.classification_model_version_3`
OPTIONS
  ( model_type='LOGISTIC_REG',
    auto_class_weights=TRUE
  ) AS
SELECT
  zip_city,
  tree_dbh,
  boroname,
  nta_name,
  health,
  sidewalk,
  spc_latin as label
FROM
  `06_nyc_trees.training_table`;
```
与之前的机器学习模型相比，在classification_model_version_3中，我们包括了health字段，它描述了我们的树木的健康状况，以及sidewalk字段，用于指定树木的根是否损坏了相邻的人行道。
查看我们最后一个机器学习模型在0.7696的性能。

小贴士

尽管使用更多特征可以增加 BigQuery ML 分类模型的 ROC AUC 值，但我们需要考虑性能提升和实现它所花费的资源之间的平衡。在现实场景中，尤其是在数据量真的很大时，我们需要选择那些可能对我们 BigQuery ML 模型性能产生最高影响的特征。

在本节中，我们创建了不同的机器学习模型，尝试在我们的数据集中使用不同的特征。在下一节中，我们将使用具有最高 ROC AUC 值的模型：classification_model_version_3。

接下来，让我们利用评估数据集评估我们的机器学习模型的表现。

评估多类逻辑回归模型

在本节中，我们将执行查询以检查多类逻辑回归模型的表现。

对于我们的 BigQuery ML 模型的评估阶段，我们将使用ML.EVALUATE函数和evaluation_table表，该表专门创建用于托管评估记录。

如我们所见，评估是在模型训练阶段使用的相同字段上进行的，但这些字段是从完全独立于训练数据集创建的evaluation_table表中提取的。

外部SELECT语句提取了ML.EVALUATE函数返回的roc_auc值。它还提供了一个从'POOR'开始，到'EXCELLENT'等级，经过一些中间阶段如'NEEDS IMPROVEMENTS'和'GOOD'，的模型质量的描述。

让我们执行以下查询以提取我们 ML 模型的关键性能指标：

SELECT
  roc_auc,
  CASE
    WHEN roc_auc > .9 THEN 'EXCELLENT'
    WHEN roc_auc > .8 THEN 'VERY GOOD'
    WHEN roc_auc > .7 THEN 'GOOD'
    WHEN roc_auc > .6 THEN 'FINE'
    WHEN roc_auc > .5 THEN 'NEEDS IMPROVEMENTS'
  ELSE
  'POOR'
END
  AS model_quality
FROM 
  ML.EVALUATE(MODEL `06_nyc_trees.classification_model_version_3`,
    (
    SELECT
       zip_city,
       tree_dbh,
       boroname,
       nta_name,
       health,
       sidewalk,
       spc_latin as label
     FROM `06_nyc_trees.evaluation_table`));

从以下截图，我们可以看到查询结果——roc_auc值达到了 0.77 以上。我们的 BigQuery ML 模型的结果可以被认为是良好的：

图 6.8 – 查询提取 BigQuery ML 模型的 ROC AUC 值和模型质量的简短描述

现在我们已经验证了该机器学习模型在非重叠评估数据集上也能保持其性能，我们可以开始使用它来对classification_table表中的树木进行分类。

使用多类逻辑回归模型

在本节中，我们将测试我们的 ML 模型并分析结果。

要使用我们的 BigQuery ML 模型，我们将使用ML.PREDICT函数和classification_table表，该表存储了记录，以测试我们的模型，如下代码块所示：

SELECT
  tree_id,
  actual_label,
  predicted_label_probs,
  predicted_label
FROM
  ML.PREDICT (MODEL `06_nyc_trees.classification_model_version_3`,
    (
    SELECT
       tree_id,
       zip_city,
       tree_dbh,
       boroname,
       nta_name,
       health,
       sidewalk,
       spc_latin as actual_label
    FROM
      `06_nyc_trees.classification_table`
     ));

查询语句由SELECT关键字组成，它提取了tree_id、字段中物种的实际值actual_label以及预测字段predicted_label_probs和predicted_label。

ML.PREDICT函数应用于SELECT语句，从classification_table中提取特征和实际物种。actual_label字段将仅作为预测的基准，而不是在预测阶段使用。

在以下截图中，我们可以看到之前查询执行得到的记录的结构：

图 6.9 – 分类模型生成的输出数据集的记录

在这种情况下，tree_id等于857，这棵树是Quercus palustris，并且被 BigQuery ML 模型正确分类，因为predicted_label与实际值完全相同。predicted_label_probs表示最高分类标签的置信度为 45%。所有其他可能的物种都由较低的几率来表征。

现在我们已经应用了我们的模型，让我们对分类用例的一些最终考虑进行阐述。

提出业务结论

使用上一节中得到的多类逻辑回归模型的结果，我们将对 ML 模型的有效性得出一些结论。

在之前的查询中添加一个父SELECT COUNT语句，我们可以计算与总记录数相比有多少预测是正确的。

让我们执行以下查询来计算我们的 BigQuery ML 模型在classification_table表中正确分类树木的频率：

SELECT COUNT(*)
FROM (
      SELECT
        tree_id,
        actual_label,
        predicted_label_probs,
        predicted_label
      FROM
        ML.PREDICT (MODEL `06_nyc_trees.classification_model_version_3`,
          (
          SELECT
             tree_id,
             zip_city,
             tree_dbh,
             boroname,
             nta_name,
             health,
             sidewalk,
             spc_latin as actual_label
          FROM
            `06_nyc_trees.classification_table`
           )
        )
)
WHERE
      actual_label = predicted_label;

SELECT COUNT查询的结果返回了 13,323 个预测值，其中正确预测的标签值为 13,323。

考虑到classification_table表的总大小为 27,182，我们可以声明在 49%的情况下，我们的 ML 模型能够根据其特征和位置预测正确的树种。

这可能看起来是一个不好的结果，但我们需要考虑多分类逻辑回归比二分类更复杂，因为存在多个选项可能会误导我们模型的结果。

摘要

在本章中，我们构建了我们的第一个多分类模型。在简要介绍用例之后，我们发现了多分类逻辑回归是什么以及它是如何根据特征将事件、行为和对象分类到两个以上类别的。

在深入开发 ML 模型之前，我们分析了与纽约市树木相关的数据集模式，并应用了一些必要的质量检查，以构建一个有效的 ML 模型。

在训练阶段，我们使用不同的特征训练了三个不同的 ML 模型，以逐步提高 BigQuery ML 模型的表现。

然后，我们选择了第三个 ML 模型，并对其进行了评估。在这个阶段，我们注意到 ML 模型能够在新记录上保持其性能，并准备进入下一阶段。

在最后一步，我们使用我们的 ML 模型将纽约市的树木分类为五个不同的类别，并利用它们的特征，如大小、健康状况和在城市中的位置。

我们还计算出我们的分类模型在 49%的情况下能够正确分类树种。

在下一章中，我们将介绍无监督 ML 和 K-Means 聚类技术。

进一步资源

纽约市树木普查公共数据集：console.cloud.google.com/marketplace/product/city-of-new-york/nyc-tree-census
BigQuery ML 创建模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create
BigQuery ML 评估模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
BigQuery ML 预测：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-predict
BigQuery ML 多类逻辑回归示例: cloud.google.com/bigquery-ml/docs/logistic-regression-prediction

第三部分：使用 BigQuery ML 的高级模型

在本节中，将解释和展示一些额外的和高级的机器学习模型，并使用 BigQuery ML 提供实际动手操作的示例。

本节包括以下章节：

第七章, 使用 K-Means 算法进行聚类
第八章, 使用时间序列进行预测
第九章, 通过矩阵分解推荐合适的产品
第十章, 使用 XGBoost 预测布尔值
第十一章, 实现深度神经网络

第七章：使用 K-Means 算法进行聚类

在本章中，我们将介绍无监督机器学习，并学习如何使用 BigQuery ML 构建 K-Means 算法将相似数据聚类到多个类别中。

当我们拥有没有任何标签的数据集，并且需要在没有初始知识的情况下推断数据结构时，无监督机器学习特别有用。

在不同的行业中，根据一组特定的特征识别相似的事件、对象和人物非常有价值。K-Means 聚类通常用于根据一组特定的特征识别相似的客户、文档、产品、事件或物品。

在本章中，我们将重点关注广泛用于揭示结构化和非结构化数据相似性的 K-Means 聚类算法。我们将通过构建 K-Means 聚类模型所需的所有步骤，利用 BigQuery ML 进行操作。

采用增量方法，我们将探讨以下主题：

介绍业务场景
发现 K-Means 聚类
探索和理解数据集
训练 K-Means 聚类模型
评估 K-Means 聚类模型
使用 K-Means 聚类模型
提炼业务结论

技术要求

本章要求您能够访问网络浏览器，并能够利用以下内容：

一个用于访问 GCP 控制台的 Google Cloud Platform (GCP) 账户
一个用于托管 BigQuery 数据集的 GCP 项目

现在我们已经准备好了技术要求，让我们深入分析和发展我们的 BigQuery ML 聚类模型。

查看以下视频以查看代码的实际应用：bit.ly/2Rx2Uk5

介绍业务场景

想象一下，你是一名为芝加哥大型出租车公司工作的商业分析师。这些出租车公司每天要完成数千次行程，以满足整个城市的公共交通需求。出租车司机的工作和行为对于为公司创造收入和为所有客户提供有效服务至关重要。

对于我们的业务场景，让我们想象所有出租车公司都想给表现最好的司机额外奖励。公司的目标是根据生成的收入和驾驶速度将司机分为三个不同的类别。这三个群体可以描述如下：

顶级司机是全年收入和效率最佳的员工。这个群体将获得巨大的额外奖励。
优秀司机是表现良好但并不突出的司机。这个群体将不会获得任何奖励。
中性司机是在收入和效率方面结果中性或负面的司机。

识别聚类参数不是事先已知的，因为它们可以根据不同的因素（如盈利能力、速度和交通状况）而变化。有些年份比其他年份更有利可图，而且驾驶速度可能会受到特定交通状况的影响。

作为一名商业分析师，你的任务是找到最佳的算法，根据描述的分类将芝加哥出租车司机聚类，以便根据他们的表现将司机分为三个类别。

既然我们已经解释并理解了问题陈述，让我们看看我们可以用来预测数值（如行程持续时间）的机器学习技术。

发现 K-Means 聚类

在本节中，我们将了解什么是无监督学习，并学习K-Means聚类技术的基础知识。

K-Means是一种无监督学习算法，用于解决聚类问题。这种技术用于将数据分类到一组类别中。字母k代表事先固定的聚类数量。在我们的业务场景中，我们将使用三个不同的聚类。

重要提示

虽然监督学习基于对训练数据集中标签输出值事先的知识，但无监督学习并不利用标记数据集。其目标是推断训练数据集中的数据结构，而不需要任何先验知识。

每个数据簇都由一个质心来表征。质心代表簇的中点，在训练阶段根据模型特征被识别。

在 K-Means 聚类模型训练之后，每个实体都可以与最近的质心关联，并包含在其中一个k个聚类中。

在下面的图中，你可以查看基于两个特征和一个k等于3的值的简单聚类模型的图形表示：

![图 7.1 – K-Means 聚类的图形表示

图 7.1 – K-Means 聚类的图形表示

在前面的笛卡尔图中，你可以看到一些由点表示的观测值。该图由两个轴组成，这两个轴对应于用于训练 K-Means 聚类机器学习模型的特征。

根据两个特征值的差异，一些观测值比其他观测值更接近。假设我们需要将观测值聚类成三个不同的类别，K-Means 模型被训练出来以找到将观测值划分为不同类别的三个区域。

我们不会在本书中详细介绍 K-Means 聚类算法的所有细节，但我们可以提到一些此类算法适用的用例示例。在现实生活中，我们可以找到许多可以用聚类模型解决的问题，例如以下情况：

客户细分：在公司的客户基础上找到相似的客户，以提高营销活动和促销活动的有效性
员工细分：识别表现最佳的员工
文档分类：根据标签、主题、作者和发布日期将文档聚类到多个类别中

在我们的业务场景中，我们将基于三个不同的聚类：顶级、良好和中性驾驶员，训练一个 K-Means 聚类模型。为了实现我们的目标，我们将使用有关每位出租车驾驶员产生的收入和驾驶速度的信息，驾驶速度是行驶英里数与每次行程花费时间的比率。

我们已经学习了 K-Means 聚类的基础知识，现在是时候看看我们将用于构建机器学习模型的数据集了。

探索和理解数据集

在深入到机器学习实现之前，我们将开始分析用于训练我们的机器学习模型的数据集。

对于这个用例，我们将使用我们在第五章中已经使用过的 BigQuery 公共数据集，使用二元逻辑回归预测布尔值。这个数据集包含了由芝加哥市收集的出租车行程信息，您可以通过以下链接找到：console.cloud.google.com/marketplace/details/city-of-chicago-public-data/chicago-taxi-trips。

让我们先清楚地了解我们数据集中所拥有的信息，以便构建我们的 K-Means 聚类模型。

理解数据

在本节中，我们将探索我们将用于开发我们的 BigQuery ML 模型的数据结构。

要开始探索数据，我们需要做以下几步：

登录 GCP，并通过导航菜单访问BigQuery用户界面。
在第二章中创建的项目下创建一个新的数据集，设置您的 GCP 和 BigQuery 环境。对于这个用例，我们将创建一个带有默认选项的07_chicago_taxi_drivers数据集。
打开bigquery-public-data GCP 项目，该项目托管所有 BigQuery 公共数据集，浏览项目直到找到chicago_taxi_trips数据集。在这个公共数据集中，我们可以看到只有一个 BigQuery 表：taxi_trips。这个表包含了关于在芝加哥市发生的所有出租车行程的信息，我们将使用它来训练和测试我们的 K-Means 聚类模型。

我们已经在第五章中使用了相同的数据，使用二元逻辑回归预测布尔值。因此，我们已经了解了taxi_trips表及其字段的总体架构。

在下面的屏幕截图中，您可以查看属于taxi_trips表的完整字段列表：

图 7.2 – 属于 taxi_trips 表的字段列表

对于此用例，我们关注以下字段，这些字段将用于创建我们的机器学习模型：

trip_miles：包含出租车司机在特定行程中行驶的英里数。
trip_seconds：表示每次出租车行程的持续时间，以秒为单位。
fare：这是乘客支付给出租车司机的费用，代表司机的收入。
提示：此列包含出租车司机从乘客那里收到的小费金额。

我们故意忽略与出租车行程成本相关的其他列，例如tolls和extras，因为这些值不会直接受到出租车司机活动的影响。

在本节中，我们已选择了用于训练我们的机器学习模型的表和列。现在，是时候查看数据，以便我们了解如何使用它。

检查数据质量

在本节中，我们在开发我们的机器学习模型之前将应用一些数据质量检查。

数据质量对于构建有效的 K-Means 聚类模型至关重要。由于目标是将观测值聚类到多个类别中，数据中的异常值可以基于数据中的错误值创建不平衡的聚类。

让我们开始分析用于构建我们的机器学习模型的数据集，如下所示：

为了确定我们数据集的时间范围，让我们提取trip_start_timestamp字段的最低值和最高值，如下所示：
```
SELECT MAX(trip_start_timestamp),
       MIN(trip_start_timestamp)
FROM
`bigquery-public-data.chicago_taxi_trips.taxi_trips`;
```
在执行此2013到2020。

查询结果如下所示：

图 7.3 – 查询结果显示了数据集的时间范围

为了解决我们的业务场景，我们可以关注发生在2020年的出租车行程。
在第二步中，我们将检查速度（以每小时英里为单位）和出租车司机收入的最高值。让我们执行以下查询：
```
SELECT MAX (speed_mph), MAX (tot_income)
FROM (
      SELECT taxi_id,
             AVG(trip_miles/(trip_seconds/60/60)) AS speed_mph,
             SUM (fare+tips) AS tot_income
      FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips` 
      WHERE 
            EXTRACT(YEAR from trip_start_timestamp) = 2020
            AND trip_seconds > 0
            AND trip_miles >0
            AND fare > 0
      GROUP BY taxi_id);
```
内部SELECT语句通过将trip_miles字段的值除以以小时表示的行程持续时间（trip_seconds/60/60）来计算平均速度。计算出的值存储在speed_mph列中。它还创建了tot_income字段，该字段将每个taxi_id字段的fare和tips值相加。使用EXTRACT(YEAR from trip_start_timestamp) = 2020过滤器，我们只选择发生在2020年的出租车行程。在trip_seconds、trip_miles和fare字段上添加过滤器，我们还排除了数据集中可能出现的所有空值和NULL值。最外层的SELECT语句使用MAX (speed_mph), MAX (tot_income)关键字确定平均速度和收入的最高值。

查询的结果在以下屏幕截图中进行展示：

图 7.4 – 查询结果显示了速度和收入方面的异常值

从结果来看，很明显，数据集中包含一些与实际用例不兼容的异常值。事实上，最大平均速度约为 667 英里/小时，出租车司机的最高收入超过 100 万美元（USD）。

我们刚刚执行的查询指出，我们的数据集中存在一些不切实际的数据值，需要在接下来的步骤中过滤掉。

现在我们已经对我们的数据集进行了一些质量检查，让我们专注于创建我们的训练数据集。

创建训练数据集

对于 K-Means 聚类，我们只需要创建一个用于训练和测试机器学习模型的训练数据集。

让我们开始创建将用于训练两个不同的 K-Means 聚类模型的训练数据集，如下所示：

首先，让我们通过运行以下代码创建一个只包含speed_mph字段作为 K-Means 聚类模型输入特征的表格：

CREATE OR REPLACE TABLE `07_chicago_taxi_drivers.taxi_miles_per_minute` AS 
SELECT *
FROM (
                SELECT taxi_id,
                         AVG(trip_miles/(trip_seconds/60/60)) AS speed_mph
                FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips` 
                WHERE 
                      EXTRACT(YEAR from trip_start_timestamp) = 2020
                       AND trip_seconds > 0
                       AND trip_miles >0
                GROUP BY taxi_id
      )
WHERE 
      speed_mph BETWEEN 0 AND 50;

查询在07_chicago_taxi_drivers数据集中创建了taxi_miles_per_minute表格。

表格包含两个不同的字段：taxi_id列中的出租车标识符，以及speed_mph字段中的平均速度（以英里/小时表示）。平均速度是使用GROUP BY taxi_id子句为taxi_trips表中的每个taxi_id字段计算的。新表格仅包括 2020 年发生的出租车行程。

查询的最后两行包含用于过滤异常值的WHERE子句。我们假设最大合理的平均速度是50英里/小时。

在第二步中，我们将创建另一个表格来存储额外的特征（即tot_income），如下所示：

CREATE OR REPLACE TABLE `07_chicago_taxi_drivers.taxi_speed_and_income` AS
SELECT *
FROM (
        SELECT taxi_id,
                AVG(trip_miles/(trip_seconds/60/60)) AS speed_mph,
               SUM (fare+tips) AS tot_income
        FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips` 
        WHERE 
              EXTRACT(YEAR from trip_start_timestamp) = 2020
              AND trip_seconds > 0
              AND trip_miles >0
              AND fare > 0
        GROUP BY taxi_id
      )
WHERE 
      speed_mph BETWEEN 0 AND 50
      AND tot_income BETWEEN 0 AND 150000;

查询的执行生成了taxi_speed_and_income表格。此表格包括使用与步骤 1相同的规则计算的speed_mph字段。表格还包括tot_income字段。此值是每个taxi_id字段和 2020 年整个期间的fare和tips的SUM。

与步骤 1中创建的表格相比，我们添加了一个额外的过滤器，将年度tot_income值限制在 150,000。

此第二个表格将用于创建另一个基于两个speed_mph和tot_income特征的 K-Means 聚类机器学习模型。

现在我们已经创建了我们的 BigQuery ML 模型将要训练的表格，让我们深入到机器学习模型的创建中。

训练 K-Means 聚类模型

在本节中，我们将创建两个不同的 K-Means 机器学习模型。第一个模型将使用 taxi_miles_per_minute 作为训练数据集，而第二个模型将包括 tot_income 作为特征，并利用 taxi_speed_and_income。让我们按以下步骤进行：

作为第一步，让我们通过运行以下代码开始训练一个名为 clustering_by_speed 的机器学习模型：
```
CREATE OR REPLACE MODEL `07_chicago_taxi_drivers.clustering_by_speed`
OPTIONS(model_type='kmeans', num_clusters=3, kmeans_init_method = 'KMEANS++') AS
  SELECT * EXCEPT (taxi_id)
  FROM `07_chicago_taxi_drivers.taxi_miles_per_minute`;
```
SQL 语句的前几行由 CREATE OR REPLACE MODEL 关键字组成，后跟 07_chicago_taxi_drivers.clustering_by_speed 机器学习模型的标识符和 OPTIONS 子句。

现在，让我们看看我们用来训练机器学习模型的选项。选定的模型类型是 'kmeans'。此选项描述了我们用于训练模型的技术。num_clusters 选项的值为 3，因为我们试图将观测值分类到三个不同的簇中：Top、Good 和 Neutral。

默认情况下，BigQuery ML 使用随机起点开始训练 K-Means 聚类算法。机器学习模型的质量也取决于这一点，这一点是由 BigQuery 随机选择的。通过使用 kmeans_init_method = 'KMEANS++' 选项，该点利用 taxi_miles_per_minute 表初始化，除了 taxi_id 列，该列仅在预测阶段使用。
在第一个机器学习模型训练完成后，让我们再训练第二个模型，该模型还包括出租车司机在该年的 tot_income 值，如下面的代码片段所示：
```
CREATE OR REPLACE MODEL `07_chicago_taxi_drivers.clustering_by_speed_and_income`
OPTIONS(model_type='kmeans', num_clusters=3, standardize_features = true, kmeans_init_method = 'KMEANS++') AS
  SELECT * EXCEPT (taxi_id)
  FROM `07_chicago_taxi_drivers.taxi_speed_and_income`;
```
这个查询与用于创建先前 K-Means 聚类模型的 SQL 语句非常相似，但我们立即可以注意到一个相关的差异。clustering_by_speed_and_income 模型是使用一个额外的选项 standardize_features = true 训练的。当您有不同数量级的数值特征时，此选项特别有用。在这种情况下，模型正在使用 speed_mph 字段（从 0 到 50）和 tot_income 字段，其值可以达到 150,000。

现在我们已经基于 K-Means 聚类算法训练了两个不同的机器学习模型，让我们看看如何利用 BigQuery ML SQL 语法和 BigQuery 用户界面（UI）来评估它们。

评估 K-Means 聚类模型

在本节中，我们将学习如何评估我们的 K-Means 聚类模型性能。

K-Means 聚类模型的评估阶段与我们之前章节中执行的监督机器学习模型不同。让我们看看评估我们的机器学习模型需要采取的步骤，如下所示：

让我们通过运行以下代码提取上一节中训练的第一个机器学习模型的质心：
```
SELECT *
FROM ML.CENTROIDS
        (MODEL `07_chicago_taxi_drivers.clustering_by_speed`)
ORDER BY centroid_id;
```
ML.CENTROIDS函数返回 K-Means 模型质心的信息。它接受模型名称作为输入，放在圆括号内，前面是MODEL关键字。

重要提示

质心代表 K-Means 聚类模型中一个集群的中心。在机器学习模型的训练阶段，质心会迭代优化以最小化质心与训练数据集中观测值之间的距离。当训练阶段结束时，质心会稳定下来。BigQuery ML 在相对损失改进小于MIN_REL_PROGRESS参数指定的值时停止迭代。

查询的执行返回三个质心，如下截图所示：

图 7.5 – 查询结果显示机器学习模型识别的质心

在这种情况下，每个质心仅用代表出租车驾驶员平均速度的speed_mph特征的数值来表示。
可以通过 BigQuery UI 获取相同的信息。从 BigQuery 导航菜单中选择clustering_by_speed模型，访问1属于第一个集群，代表平均速度最佳的出租车驾驶员：顶级驾驶员。从 BigQuery UI，我们还可以注意到 869 名出租车驾驶员属于这个集群。

第二个质心包括大部分人口，speed_mph值为 14.3222。这个质心是良好驾驶员集群的中心。

最后一个质心是速度最慢的驾驶员所在集群的中心，包含 425 个观测值，属于中性驾驶员集群。
如果我们选择从 BigQuery UI 的评估标签页分析clustering_by_speed_and_income模型，我们将看到以下信息：

图 7.7 – 基于速度和收入的聚类 BigQuery ML 模型的评估标签页

观察由第二个模型识别的集群和质心，我们可以立即注意到集群基于两个不同的特征：speed_mph和tot_income。

第一个集群，编号为1，包括速度和年收入最佳的 466 名驾驶员：顶级驾驶员。第二个集群包含表现最差的 417 名中性驾驶员。最后一个质心包括大多数驾驶员，是良好驾驶员集群。

小贴士

训练不同迭代的 K-Means 聚类可以生成不同的值，这取决于 BigQuery ML 使用的初始化种子。可能发生的情况是质心的位置与本节中显示的值不同。

现在我们已经查看了 K-Means 聚类模型训练产生的结果，让我们开始使用它们将出租车司机分类到不同的聚类中。

使用 K-Means 聚类模型

在本节中，我们将了解如何在新数据上使用我们的 K-Means 聚类模型。

要使用我们的 BigQuery ML 模型，我们将在创建用于训练机器学习模型的同一张表上使用ML.PREDICT函数。

在这种情况下，我们还将包括taxi_id列，该列标识每个出租车司机。以下查询将根据speed_mph和tot_income字段的值将每个taxi_id字段分类到最近的聚类：

SELECT
  * EXCEPT(nearest_centroids_distance)
FROM
  ML.PREDICT( MODEL `07_chicago_taxi_drivers.clustering_by_speed_and_income`,
    (
      SELECT *
      FROM
        `07_chicago_taxi_drivers.taxi_speed_and_income`
    ));

查询语句由一个SELECT关键字组成，该关键字提取了ML.PREDICT函数返回的所有列，除了nearest_centroids_distance字段。

查询的执行生成了以下屏幕截图所示的结果：

![图 7.8 – 查询结果展示了 K-Means 聚类模型的应用

![img/B16722_07_009.jpg]

图 7.8 – 查询结果展示了 K-Means 聚类模型的应用

每个taxi_id字段被分配到一个特定的质心及其对应的聚类。分配从第一列CENTROID_ID中可见。

现在我们已经应用了我们的模型，让我们制定一些最终考虑事项，并提供一份可以奖励的出租车司机名单，因为他们属于顶级司机聚类。

提炼业务结论

在本节中，我们将使用我们机器学习模型应用的结果制定一些最终考虑事项。

使用使用 K-Means 聚类模型部分中执行的查询，我们可以创建一个包含由clustering_by_speed_and_income K-Means 机器学习模型识别的顶级司机的表，如下所示：

CREATE OR REPLACE TABLE `07_chicago_taxi_drivers.top_taxi_drivers_by_speed_and_income` AS
SELECT
  * EXCEPT(nearest_centroids_distance)
FROM
  ML.PREDICT( MODEL `07_chicago_taxi_drivers.clustering_by_speed_and_income`,
    (
      SELECT *
      FROM
        `07_chicago_taxi_drivers.taxi_speed_and_income`
    ))
WHERE CENTROID_ID=1;

查询的执行生成一个包含所有被分类到CENTROID_ID=1聚类并对应于顶级司机聚类的司机的top_taxi_drivers_by_speed_and_income表。请注意，K-Means 聚类算法并不总是返回相同的分割。因此，CENTROID_ID=1的子句可以根据每个训练阶段生成的结果而变化。

此结果集包括应奖励其表现的出租车司机的标识符。

摘要

在本章中，我们构建了我们的无监督机器学习模型。在简要介绍业务场景后，我们发现了无监督机器学习是什么，并使用 K-Means 聚类算法将相似观察结果分组到同一聚类中。

在深入开发机器学习模型之前，我们对数据集进行了数据质量检查，并选择了用作机器学习模型特征的字段。

在训练阶段，我们训练了两个不同的机器学习模型，以学习如何创建 K-Means 聚类模型。

然后，我们评估了两个模型，利用 BigQuery ML SQL 语法和 BigQuery UI 中可用的功能。

在最后一步，我们测试了我们的机器学习模型，根据数据集中的特征将可用的出租车驾驶员聚类到由 K-Means 模型生成的聚类中。

最后，我们还创建了一个属于 Top Drivers 聚类的驾驶员列表，这些驾驶员可以受到奖励，因为他们可以被认为是与其他驾驶员平均水平的顶尖表现者。

在下一章中，我们将介绍使用时间序列数据进行预测。

第八章：使用时间序列进行预测

使用历史数据预测未来趋势是我们可以用机器学习做的最迷人的活动之一。

基于历史数据点和时间序列进行预测特别有趣，并且可以在不同行业中非常有用。预测可以帮助我们预测未来，也可以帮助我们识别不遵守预期模式的数据异常。

在本章中，我们将通过使用 ARIMA Plus 算法来专注于时间序列预测。这项技术可以用于预测不同领域的数值，例如公司的销售额、餐厅的顾客数量、股票价格和建筑的电力消耗。

要了解我们如何使用 BigQuery ML 来预测趋势以及有效地展示我们的结果，我们将讨论以下主题：

介绍业务场景
发现时间序列预测
探索和理解数据集
训练时间序列预测模型
评估时间序列预测模型
使用时间序列预测模型
展示预测结果

技术要求

本章要求你访问网络浏览器，并能够利用以下功能：

一个 GCP 账户以访问 Google Cloud Console
一个 GCP 项目来托管 BigQuery 数据集

现在，我们已经准备好了技术要求，让我们深入分析和开发我们的 BigQuery ML 预测模型。

查看以下视频以查看代码的实际应用：bit.ly/2QY0Qlp

介绍业务场景

想象一下你是一名为爱荷华州工作的商业分析师。该州通过收集领土内每个商店的数据来监控酒类和烈酒的零售分销。控制酒类销售对于监控公民健康和检查税收收入尤为重要。

在下面的屏幕截图中，你可以看到一家商店中典型的酒类和烈酒货架的图片：

图 8.1 – 酒店货架

对于我们的业务场景，我们可以想象爱荷华州想要利用前几年收集的历史数据来预测 2020 年前 30 天将售出的升数。

你的经理可能会要求你利用数据库中已经收集的时间序列数据来预测该州所有商店将售出的升数。

作为一名商业分析师，你的任务是找到最佳的算法来预测销售量，并以图形方式向州长的工作人员展示结果。

现在我们已经解释并理解了问题陈述，让我们看看我们可以用来使用历史数据预测销售的机器学习技术。

发现时间序列预测

时间序列是一系列按一定时间频率映射的数据点。例如，它可以包含定期收集的股票价格，特定时间段内每天的销售量，或物联网（IoT）传感器在白天测量的温度。

在以下图中，您可以看到 2020 年前 15 天由温度传感器收集的数据的时间序列图：

图 8.2 – 温度传感器生成的时间序列示例

使用时间序列分析进行预测包括使用机器学习模型通过利用已知的历史数据来预测特定测量的未来值。

BigQuery ML 提供了一种特定的机器学习算法，用于使用时间序列数据预测数值。该算法旨在执行以下操作：

自动清理和调整训练数据以克服数据质量问题，例如缺失或重复的值和峰值。
补偿由特定时期（如节假日）引起的变异。
使用季节性和趋势分解 Loess 算法分解趋势。
从数据中推断季节性。
最后，应用自回归积分移动平均（ARIMA）模型的趋势建模，使用历史数据预测未来的数值。

您可以使用 ARIMA 模型来发现时间序列数据中的隐藏模式或预测特定测量的未来值。

在本节中，我们学习了时间序列预测的基础知识。现在让我们看看我们将用于构建 BigQuery ML 模型的数据集。

探索和理解数据集

在开始开发机器学习模型之前，我们将开始查看数据集及其结构。

让我们从对 BigQuery 公共数据集中我们拥有的时间序列数据进行清晰理解开始，以便在下一节构建我们的预测模型。

理解数据

在本节中，我们将分析数据的结构以确定用于创建机器学习模型的字段。

要开始探索数据，我们需要做以下几步：

登录我们的 Google Cloud 控制台，并通过导航菜单访问BigQuery用户界面。
在我们创建的第二章，“设置您的 GCP 和 BigQuery 环境”中创建一个新的数据集。对于此用例，我们将使用默认选项创建名为08_sales_forecasting的数据集。
打开 GCP 项目iowa_liquor_sales。

如以下截图所示，BigQuery 公共数据集仅包含一个表，该表托管了爱荷华州酒类商店收集的数据：

图 8.3 – 爱荷华州酒类销售公共数据集包含爱荷华州所有酒类商店的销售数据

我们将使用sales表来构建我们的预测模型。这个表包含了自 2012 年以来爱荷华州州内所有酒类销售的信息。
让我们点击 BigQuery 导航菜单中的表名sales以访问表的模式：

图 8.4 – 表的结构列出了表中收集的所有信息
每个字段都在描述列中有很好的描述。

表包含date列，它代表销售的日子。为了我们的目的，我们将尝试预测特定一天销售的总体积。因此，我们可以注意到volume_sold_liters字段的 presence。这个数值字段表示每次交易中销售的酒类数量。

在本节中，我们已经分析了sales表的元数据，并了解了哪些字段对我们构建预测模型感兴趣。接下来，是时候查看实际数据并开始查询了。

检查数据质量

在本节中，我们将应用一些数据质量检查来分析我们的训练数据集的完整性。

让我们开始分析将要用于构建我们的 BigQuery ML 模型的表格：

为了确定数据集的时间范围，让我们从bigquery-public-data.iowa_liquor_sales.sales表提取date字段的最低值和最高值：
```
SELECT min(date), max(date) FROM `bigquery-public-data.iowa_liquor_sales.sales`; 
```
通过执行这个 SQL 语句，我们可以注意到数据从 2012 年开始，到 2020 年 11 月底结束。

查询结果如下所示：

图 8.5 – 查询结果显示数据集的时间范围

为了我们的目的，我们可以专注于 2018 年和 2019 年的销售，以预测 2020 年最初的 30 天。
在第二步中，我们将分析在选定时间段内可以找到的唯一日期数量：
```
SELECT COUNT(DISTINCT date)
FROM
        `bigquery-public-data.iowa_liquor_sales.sales`
WHERE
        EXTRACT (year from date) = 2019         OR  EXTRACT (year from date) = 2018;
```
查询COUNT和字段date中可用的DISTINCT值。使用表达式EXTRACT (year from date)，SQL 语句仅考虑发生在2018年和2019年的销售。

查询结果如下所示：

图 8.6 – 查询结果显示数据集中的唯一日期

从结果来看，数据集不包含两年中每一天的信息。这可能是由于公共假日和商店关闭导致的缺失值造成的。这不是一个大问题，因为 BigQuery ML 将在训练阶段自动管理缺失值。

现在我们已经执行了一些 SQL 查询以更好地了解我们的数据集，让我们专注于创建我们的训练数据集。

创建训练数据集

在本节中，我们将创建一个表格来存储将在下一节中用于训练预测模型的数据点。在训练模型之前，我们还将使用数据工作室来图形化分析时间序列。

为了训练我们的模型，我们将创建一个特定的表格，该表格将托管我们时间序列的历史数据点：

让我们创建一个只包含两个字段的表格。第一个是date，第二个是total_sold_liters：
```
CREATE OR REPLACE TABLE `08_sales_forecasting.iowa_liquor_sales` AS
SELECT 
        date,
        SUM(volume_sold_liters) total_sold_liters
FROM
        `bigquery-public-data.iowa_liquor_sales.sales`
WHERE
        EXTRACT (year from date) = 2019 OR  EXTRACT (year from date) = 2018
GROUP BY
        date;
```
该查询在数据集08_sales_forecasting中创建表iowa_liquor_sales。

该表包含两个不同的字段：date列表示交易发生的时间，第二个字段是计算一天内销售的酒类数量的SUM。total_sold_liters是一个基于GROUP BY date子句的聚合值，并且对于2018年和2019年的每一天。
第二步将是图形化分析存储在iowa_liquor_sales表中的数据。

如以下截图所示，从左侧的大查询导航菜单中，让我们选择数据集08_sales_forecasting然后选择表iowa_liquor_sales：

![图 8.7 – 训练表 iowa_liquor_sales 在 BigQuery 导航菜单中可见

![img/B16722_08_007.jpg]

图 8.7 – 训练表 iowa_liquor_sales 在 BigQuery 导航菜单中可见
之后，让我们点击导出然后点击使用数据工作室探索，如下截图所示：![图 8.8 – 从 BigQuery 中，可以打开数据工作室

![img/B16722_08_008.jpg]

图 8.8 – 从 BigQuery 中，可以打开数据工作室

数据工作室是由 Google 提供的一个免费数据可视化工具，与 BigQuery 原生集成，可以轻松用于在报告和图表中绘制数据。
在数据工作室中，我们可以选择时间序列图表作为图表类型，如下截图所示：![图 8.9 – 在数据工作室中，可以选择时间序列图表来可视化数据

![img/B16722_08_009.jpg]

图 8.9 – 在数据工作室中，可以选择时间序列图表来可视化数据
然后，我们可以选择日期字段作为维度，以及总销售升数作为度量，如下截图所示：![图 8.10 – 在数据工作室中，可以选择维度和度量设置来绘制图表

![img/B16722_08_010.jpg]

图 8.10 – 在数据工作室中，可以选择维度和度量设置来绘制图表
之后，我们可以转到样式选项卡，并在缺失数据组合框中选择线性插值：![图 8.11 – 线性插值选项允许改善可视化

的图表在缺失值的情况下

![img/B16722_08_011.jpg]

图 8.11 – 线性插值选项允许在存在缺失值的情况下改善图表的可视化
在这些配置之后，我们可以可视化 Data Studio 绘制的图表，该图表表示所选期间销售的酒类数量的趋势线：

图 8.12 – 时间序列以图表上的蓝色线条在 Data Studio 中显示

现在我们已经创建了我们的预测模型将进行训练和可视化的表，并在图表中显示了数据，让我们深入了解机器学习模型的创建。

训练时间序列预测模型

在本节中，我们将训练 BigQuery ML 时间序列预测模型。

让我们开始训练机器学习模型 liquor_forecasting，执行以下 SQL 语句：

CREATE OR REPLACE MODEL `08_sales_forecasting.liquor_forecasting`
OPTIONS
 (model_type = 'ARIMA',
  time_series_timestamp_col = 'date',
  time_series_data_col = 'total_sold_liters',
  auto_arima = TRUE,
  data_frequency = 'AUTO_FREQUENCY'
) AS
SELECT *
FROM
 `08_sales_forecasting.iowa_liquor_sales`;

SQL 语句由以下部分组成：

查询的前几行以关键字 CREATE OR REPLACE MODEL 开头，后面跟着机器学习模型的标识符 `08_sales_forecasting.liquor_forecasting`，以及 OPTIONS。
现在，让我们专注于我们用来训练机器学习模型的选项。选定的模型类型是 'ARIMA'。此选项描述了我们用来训练 BigQuery ML 预测模型的算法。
time_series_timestamp_col = 'date' 指定了用于在时间序列中存储数据点时间的列。
下一个选项选择 total_sold_liters 列作为存储每个数据点值的列，并由子句 time_series_data_col = 'total_sold_liters' 表示。
属性 auto_arima 设置为 TRUE，允许 BigQuery ML 自动识别模型的参数 p、d 和 q。
最后一个参数 'AUTO_FREQUENCY'，BigQuery 自动推断时间序列的频率。在这种情况下，频率是每日的。其他选项有 'HOURLY'、'DAILY'、'WEEKLY'、'MONTHLY'、'QUARTERLY' 和 'YEARLY'。
SQL 语句的最后部分由对训练表 iowa_liquor_sales 应用 SELECT 语句组成。

现在我们已经基于 ARIMA 算法训练了时间序列预测模型，让我们看看如何使用 BigQuery ML 语法和 BigQuery UI 来评估它。

评估时间序列预测模型

在本节中，我们将评估我们在前一节中训练的机器学习模型的性能。

时间序列模型的评估阶段可以通过使用 ML.EVALUATE BigQuery ML 函数来完成。

让我们执行以下查询以提取所有表征 ARIMA 模型的评估参数：

SELECT *
FROM
 ML.EVALUATE(MODEL `08_sales_forecasting.liquor_forecasting`);

查询的结果在以下屏幕截图中进行了可视化：

图 8.13 – 从时间序列预测模型评估中提取的记录

每一行定义了一个被分类为 ARIMA(p,d,q) 模型的非季节性 ARIMA 模型。对于每一行，我们可以注意到以下内容：

字段 non_seasonal_p 代表 ARIMA 模型的参数 p。行值是用于预测的自回归项的数量。它表示用于预测时间序列下一个值的观测值数量。
字段 non_seasonal_d 代表 ARIMA 模型的参数 d。行值表示需要将一个数据点与前一个数据点之间的差值应用多少次，以减轻数据集的季节性。
non_seasonal_q 代表 ARIMA 模型的参数 q。它表示用于预测时间序列下一个值的移动平均数所计算的观测值数量。
has_drift 显示是否对模型应用了漂移常数。
log_likelihood 是一个参数，用于衡量统计模型与特定数据集的拟合程度。
AIC 代表 Akaike 信息准则。此值用于评估模型的好坏。AIC 的值越低，通常越好。因此，我们可以认为第一个模型是最好的。
variance 衡量数据点与序列平均值之间的距离。
seasonal_periods 列表示我们数据中的季节性模式。在这种情况下，BigQuery ML 已经在销售时间序列中识别出 WEEKLY 和 YEARLY 模式。

现在我们已经介绍了我们时间序列预测模型的性能指标，让我们尝试使用它来预测 2020 年前 30 天的数据。

使用时间序列预测模型

要使用我们的 BigQuery ML 模型，我们将使用 ML.FORECAST 函数来指定预测的参数。

查询将提取由接受以下参数的预测函数生成的所有字段：

模型名称 08_sales_forecasting.liquor_forecasting，前面有 MODEL 关键字。

一个包含预测的 horizon：30 天和选择的 confidence_level – 在这种情况下，80% 的 STRUCT：

SELECT
  *
FROM
  ML.FORECAST(MODEL `08_sales_forecasting.liquor_forecasting`,
              STRUCT(30 AS horizon, 0.8 AS confidence_level));

查询的执行将生成以下屏幕截图所示的记录：

图 8.14 – 预测函数生成的结果

我们可以在 图 8.14 中注意到，预测是按照 confidence_level 字段中的日期按时间顺序排列的。值为 0.8 表示 80% 的预测值应落在由字段 prediction_interval_lower_bound 和 prediction_interval_upper_bound 确定的预测区间内。

现在我们已经应用了我们的模型，让我们了解如何有效地使用 Data Studio 展示结果。

展示预测结果

在本节中，我们将使用数据工作室创建一个时间序列图，以便图形化地展示预测结果。

使用以下查询，我们可以创建一个包含历史值和预测值的表格：

CREATE OR REPLACE TABLE `08_sales_forecasting.iowa_liquor_sales_forecast` AS
SELECT
  history_date AS date,
  history_value,
  NULL AS forecast_value,
  NULL AS prediction_interval_lower_bound,
  NULL AS prediction_interval_upper_bound
FROM
  (
    SELECT
      date AS history_date,
      total_sold_liters AS history_value
    FROM
      `08_sales_forecasting.iowa_liquor_sales`
  )
UNION ALL
SELECT
  CAST(forecast_timestamp AS DATE) AS date,
  NULL AS history_value,
  forecast_value,
  prediction_interval_lower_bound,
  prediction_interval_upper_bound
FROM
  ML.FORECAST(MODEL `08_sales_forecasting.liquor_forecasting`,
              STRUCT(30 AS horizon, 0.8 AS confidence_level));

执行 SQL 语句生成iowa_liquor_sales_forecast表，该表由以下内容组成：

所有记录都来自训练表iowa_liquor_sales，我们从其中提取了时间序列的history_date和history_value。我们还添加了一些NULL字段，以通过查询的第二部分与UNION ALL分隔的标准模式。
由ML.FORECAST函数生成的所有预测记录已在上一节使用时间序列预测模型中应用。特别值得注意的是，我们不仅提取了forecast_value，还提取了预测的下限和上限，分别由字段prediction_interval_lower_bound和prediction_interval_upper_bound表示。
存在CAST函数，应用于forecast_timestamp列，这是必要的，以便根据训练表的模式将数据类型从TIMESTAMP更改为DATE。

正如我们在创建训练数据集部分所做的那样，我们现在可以执行以下操作：

从 BigQuery 导航菜单中选择我们刚刚创建的iowa_liquor_sales_forecast表。
点击导出然后使用数据工作室探索以访问报告工具。
从图表面板中选择时间序列图表。
按照以下截图所示，将历史值、预测值、预测区间下限和预测区间上限拖放到指标面板中：

图 8.15 – 数据面板允许我们自定义图表的指标
移动到样式面板，向下滚动直到找到缺失数据部分。在这里，我们选择线性插值。
然后，在屏幕顶部，我们可以对日期列应用过滤器，以便我们的图表仅关注从 2019 年 12 月 1 日到 2020 年 1 月 30 日的期间：

图 8.16 – 在日期列上应用过滤器
点击应用，图表最终将如图所示可视化：![图 8.15 – 数据面板允许我们自定义图表的指标

图 8.17 – 数据工作室中的时间序列图表

观察图表的图例，我们可以通过不同的颜色可视化历史值和预测值。我们还可以注意到，预测值线始终包含在预测区间内。

摘要

在本章中，我们构建了我们的时间序列预测机器学习模型。在介绍业务场景之后，我们发现了时间序列预测是什么，特别是用于从历史数据点预测值的 ARIMA 算法。

在深入开发 BigQuery ML 模型之前，我们对爱荷华州收集的与该地区商店酒类销售相关的数据进行了分析。为此，我们引入了报告工具 Data Studio 的使用，它可以通过 BigQuery UI 容易地访问，并利用它绘制时间序列图表。

然后，我们创建了我们的训练表，其中包含历史数据的时间序列，并在其上训练了我们的 BigQuery ML 模型。然后，我们通过利用 BigQuery ML SQL 语法评估了时间序列预测模型。

在最后一步，我们使用 30 天的预测范围预测了爱荷华州销售的酒类数量，并在 Data Studio 仪表板上绘制了结果，该仪表板可以向非技术人员展示。

在下一章中，我们将介绍矩阵分解算法来构建推荐引擎。

进一步资源

爱荷华州酒类零售销售公共数据集: console.cloud.google.com/marketplace/product/iowa-department-of-commerce/iowa-liquor-sales
BigQuery ML 创建模型: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create
BigQuery ML 评估模型: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
BigQuery ML 预测: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-forecast
BigQuery ML 时间序列预测示例: cloud.google.com/bigquery-ml/docs/arima-single-timeseries-forecasting-tutorial

第九章：通过矩阵分解建议合适的产品

建议合适的产品是机器学习（ML）最常见应用之一。每天，产品推荐系统影响着我们在互联网上的选择。新闻通讯、电子商务网站、视频流媒体公司以及许多其他服务利用这种强大的 ML 技术，为我们提供有关可能购买或喜欢的产品的有意义建议。

在本章中，我们将以实际操作和实用性的方法，执行构建新推荐引擎的主要实现步骤，该引擎使用矩阵分解算法。

通过逐步和增量方法，利用 BigQuery ML，我们将涵盖以下主题：

介绍业务场景
发现矩阵分解
配置 BigQuery Flex Slots
探索和准备数据集
训练矩阵分解模型
评估矩阵分解模型
使用矩阵分解模型
提出业务结论

技术要求

本章要求您能够访问网络浏览器，并利用以下资源：

一个 GCP 账户来访问 Google Cloud 控制台。
一个 GCP 项目来托管 BigQuery 数据集。
BigQuery Flex slots 用于在 BigQuery ML 中训练矩阵分解模型。这类算法的训练仅适用于固定价格客户或预留客户。如果您使用的是按需定价的 BigQuery，我们将向您展示如何使用 BigQuery Flex Slots。

现在技术要求已经明确，让我们看看关于 BigQuery ML 矩阵分解模型的使用案例。

介绍业务场景

想象一下，你是一名为 Google 商品电子商务店工作的商业分析师。该网站向不同用户销售不同的谷歌品牌产品。一些用户已注册并有自己的标识符，他们的点击流活动收集在特定的数据集中。

重要提示

点击流数据是用户在特定网站上导航时留下的数字足迹。这些数据通常包括他们访问的网页、在每个页面上花费的时间、使用的设备、流量来源以及其他相关信息。

在这个场景中，数据是通过 Google 从 Google 商品电子商务门户使用Google Analytics 360收集的。这个工具可以集成到任何网站，并允许我们收集有关门户中每个页面上用户行为的详细信息，以便进行进一步分析和分析。

以下截图是 Google 商品店，该店销售谷歌品牌的设备：

图 9.1 – Google 商品店的截图

对于我们的业务场景，我们将设想我们的经理要求我们构建一个新的推荐引擎，以提高客户的使用体验以及他们的电子商务销售额。

我们的目标是开发一个机器学习模型，为在网站上注册的每位客户推荐合适的产品。为了实现这一目标，我们将使用已经收集并发布在 BigQuery 公共数据集中的 Google 商品店点击流数据。

作为业务分析师，我们的工作是分析数据，构建一个有效的推荐引擎，并使用现有数据向营销团队提供有意义的见解。

现在我们已经解释并理解了业务场景，让我们来看看我们将用于构建电子商务门户推荐引擎的机器学习技术。

发现矩阵分解

在本节中，我们将学习什么是矩阵分解，以及它是如何被用来构建推荐引擎的。

矩阵分解代表了一类通常用于构建推荐引擎的算法。这些算法建立在表示用户和项目之间交互的矩阵上。在这些类型的矩阵中，以下情况会发生：

每个用户或客户都由一行表示。
每个项目或产品对应于矩阵的一列。
矩阵的每个单元格都填充了一个数值：反馈。

这种反馈代表了一个特定用户对特定项目的评分。

在下面的屏幕截图中，我们可以看到一个矩阵的例子，其中行是视频流服务的客户，列是平台提供的电影。一些单元格包含一个从1到5的评分：

![图 9.2 – 推荐矩阵的表示

![img/B16722_09_002.jpg]

图 9.2 – 推荐矩阵的表示

在这个例子中，我们可以说用户 1对电影闪灵给出了平均评分，但对泰坦尼克号不喜欢。另一方面，用户 4对泰坦尼克号给出了最高评分，但没有对其他电影进行评分。

根据不同的业务场景，这种反馈可以被考虑为明确的或隐式的：

当用户自愿对特定项目进行评分时，例如在评论网站上，就有明确的反馈。
如果没有明确的反馈，推荐系统的开发者可以通过隐式反馈进行计算和推断。例如，如果客户购买了一个产品，我们可以假设他们会为该商品给出积极的反馈。

在电子商务数据中，用户往往不会明确给出反馈，但可以从收集过程中的其他信息中提取，例如点击次数、在特定页面上的时间或用户购买特定产品的数量。

矩阵分解算法在现实场景中得到广泛应用。以下是一些例子：

在在线书店中看到的推荐书籍。
我们可以在视频流服务中看到的推荐电视剧。
在我们的社交媒体动态中突出显示的帖子。
互联网广告系统推荐的商品。

在本节中，我们学习了矩阵分解的基础知识。现在，让我们配置 BigQuery Flex 槽位。

配置 BigQuery Flex 槽位

在本章中，我们将了解如何配置 BigQuery Flex 槽位以训练我们的机器学习模型。

BigQuery 槽位是 BigQuery 分析能力的单位，用于执行 SQL 查询和训练 BigQuery ML 模型。一个 BigQuery 槽位代表一个虚拟计算处理单元（VCPU）的计算能力。

Flex 槽位允许我们在短时间内购买 BigQuery 分析能力。它们通常用于快速满足至少持续 60 秒的资源突发需求。

启用 Flex 槽位是训练矩阵分解模型所必需的；否则，BigQuery 将在训练阶段返回错误。

让我们看看如果我们使用按需计划，我们如何启用 BigQuery Flex 槽位：

如果您尚未启用 BigQuery 预订，我们需要从左侧的 BigQuery 菜单访问预订：

图 9.3 – 从 BigQuery 导航菜单访问预订
点击购买槽位按钮以初始化 BigQuery Flex 槽位的购买过程：

图 9.4 – 预订页面截图
选择要购买的 Flex 槽位的最小数量；即100。然后，点击下一步按钮：

图 9.5 – BigQuery 购买槽位过程
在确认文本框中写下CONFIRM并点击蓝色购买按钮来确认您的选择：

图 9.6 – 确认您的 BigQuery 槽位购买
一旦确认购买，您就可以切换到分配选项卡来分配您刚刚购买的预订。
在分配选项卡上，在第一个下拉菜单中选择您的 GCP 项目，在第二个下拉菜单中选择 Flex 槽位的预订。然后，点击创建按钮以完成您的配置：

图 9.7 – 分配 BigQuery 槽位
当分配完成时，我们可以返回 BigQuery 主页。

重要提示

警告：请记住在本用例结束时禁用 BigQuery 槽位的预订。每个 BigQuery 槽位每小时收费 0.04 美元。忘记禁用此预订将为您的 GCP 项目产生意外的账单。

在本节中，我们学习了如何购买 BigQuery Flex Slots 以便我们可以使用矩阵分解。现在，我们将专注于数据探索和准备步骤。

探索和准备数据集

在本节中，我们将分析我们将用于训练 BigQuery ML 模型的数据，并应用数据准备步骤。

让我们先清楚地了解 BigQuery 公共数据集中可用的 Google Analytics 数据，以便我们可以构建我们的推荐系统。

理解数据

在本节中，我们将导入必要的数据，然后理解数据集中将用于训练 BigQuery ML 模型的最相关字段。

在我们开始开发机器学习模型之前，我们将查看数据集及其模式。要开始探索数据集，我们需要执行以下操作：

登录我们的 Google Cloud Console，并通过导航菜单访问 BigQuery 用户界面。
在我们创建的项目下创建一个新的数据集，该项目位于 第二章，设置您的 GCP 和 BigQuery 环境。对于此用例，我们将使用默认选项创建 09_recommendation_engine 数据集。
之后，我们需要打开托管 BigQuery 公共数据集的 bigquery-public-data GCP 项目，并浏览数据集，直到我们找到 google_analytics_sample。
BigQuery 公共数据集包含多个表，这些表托管着 Google Analytics 示例数据。每个表根据它所引用的年份和月份展示不同的后缀：![图 9.8 – 包含 ga_sessions 表的 Google Analytics 示例数据集

图 9.8 – 包含 ga_sessions 表的 Google Analytics 示例数据集

我们将使用 ga_sessions 表来构建我们的矩阵分解模型。

小贴士

ga_sessions 表没有很好地描述，但如果我们需要关于这个数据集的更多信息，我们可以利用 BigQuery 文档中提供的示例，文档链接为 support.google.com/analytics/answer/4419694?hl=en。
为了简化数据访问过程，让我们创建一个统一的单一表，将所有具有不同后缀的表合并在一起。让我们执行以下 SQL 语句：
```
CREATE OR REPLACE TABLE `09_recommendation_engine.all_ga_sessions` AS
SELECT * FROM `bigquery-public-data.google_analytics_sample.ga_sessions_*`;
```
查询创建了一个名为 all_ga_sessions 的新表，位于我们的 09_recommendation_engine 数据集中。此表将来自不同 ga_sessions 表的所有数据存储到一个独特的结构中。为了统一所有记录，我们使用了通配符字符，*。

小贴士

将 ga_sessions_* 表放入我们的新结构 all_ga_sessions 中。
现在，我们可以简单地查询 all_ga_sessions 以预览其架构：
```
SELECT * FROM `09_recommendation_engine.all_ga_sessions`
TABLESAMPLE SYSTEM (10 PERCENT);
```
查询结果指出，表的架构相当复杂，包含多个嵌套字段。幸运的是，为了我们的目的，我们只需关注其中的一些：

fullVisitorID 代表每个浏览谷歌网站的注册用户的标识符。

productSku 是识别 Google 目录中特定产品的产品代码。一些产品的示例包括杯子、T 恤、包和袜子。

action_type 列表示用户在网页会话期间执行的操作。如果此字段等于 6，则该行表示客户购买的具体产品。

既然我们已经确定了哪些列将用于我们的 ML 模型，现在是时候准备我们的训练数据集了。

创建训练数据集

在本节中，我们将创建将托管我们 BigQuery ML 模型训练数据的表。

为了训练我们的模型，我们将创建一个表，该表将托管网站上注册客户所进行的所有购买。

让我们创建包含三个字段的 product_purchases 表：

每个用户的代码：fullVisitorId
购买产品的标识符：purchased_product_id
quantity 字段，指定客户购买的产品数量

执行以下 SQL 语句以创建表：

CREATE OR REPLACE TABLE `09_recommendation_engine.product_purchases` AS
SELECT    fullVisitorId,
          hits_product.productSKU AS purchased_product_id,
          COUNT(hits_product.productSKU) AS quantity
FROM
          `09_recommendation_engine.all_ga_sessions`,
          UNNEST(hits) AS hits,
          UNNEST(hits.product) AS hits_product
WHERE fullVisitorId IN (
                         SELECT fullVisitorId
                         FROM
                `09_recommendation_engine.all_ga_sessions`,
                         UNNEST(hits) AS hits
                         WHERE 
                     hits.eCommerceAction.action_type = '6'
                         GROUP BY fullVisitorId
                          )
GROUP BY fullVisitorId, purchased_product_id;

最内层的查询从 all_ga_sessions 表中提取所有通过 fullVisitorId 识别的顾客，这些顾客至少在电子商务门户上购买过产品。为了识别这些购买，我们在 WHERE 子句中添加了 hits.eCommerceAction.action_type = '6'。为了获取 fullVisitorId 的唯一值，查询利用了 GROUP BY fullVisitorId 子句。

在嵌套查询的 FROM 子句中，我们使用 UNNEST 函数提取原始表中存在的嵌套字段并访问它们。

重要提示

UNNEST 是一个用于将数组转换为多行集合的函数。它接受一个数组作为输入，并返回一个表，其中每行对应数组中的一个项目。

在最外层的查询中，我们仅提取与我们用例相关的三个字段：fullVisitorId、purchased_product_id 和我们的总 quantity。此最后指标是通过使用 SUM 操作符在特定用户购买特定产品时进行的所有交易获得的。

既然我们已经创建了推荐引擎将训练的表，让我们创建 BigQuery ML 模型。

训练矩阵分解模型

在本节中，我们将训练 BigQuery ML 矩阵分解模型，以便使用我们已准备好的电子商务数据构建推荐系统。

让我们从执行以下 SQL 语句开始训练 purchase_recommender ML 模型：

CREATE OR REPLACE MODEL `09_recommendation_engine.purchase_recommender`
OPTIONS(model_type='matrix_factorization',
        user_col='fullVisitorID',
        item_col='purchased_product_id',
        rating_col='quantity',
        feedback_type='implicit'
        )
AS
SELECT fullVisitorID, purchased_product_id, quantity 
FROM `09_recommendation_engine.product_purchases`;

查询的前几行由 CREATE OR REPLACE MODEL 关键字组成，后面跟着新 ML 模型的标识符 `09_recommendation_engine.purchase_recommender` 和 OPTIONS。

现在，让我们关注我们用于训练 BigQuery ML 模型的 OPTIONS 值：

模型类型是 'matrix_factorization'。此选项描述了我们用于训练推荐模型的算法。
user_col='fullVisitorID' 选项指定哪个列代表推荐引擎的用户。在我们的案例中，我们使用 fullVisitorID 字段，该字段分配给电子商务门户的注册客户。
使用 item_col='purchased_product_id' 选项时，我们使用客户购买的产品代码来识别模型中的每个项目。
由于我们没有产品的明确评分，我们将选择 feedback_type='implicit' 并使用购买的 quantity 值作为推荐引擎的评分。在这种情况下，我们假设如果用户购买了大量的产品，他们对产品感兴趣并且对产品满意。

大约 7 分钟后，矩阵分解模型将被训练，我们可以进入下一个阶段：评估阶段。

评估矩阵分解模型

在本节中，我们将评估我们在上一节中训练的矩阵分解模型的性能。

矩阵分解模型的评估阶段可以使用 ML.EVALUATE BigQuery ML 函数或通过 BigQuery UI 进行。

让我们执行以下查询以提取表征我们刚刚训练的推荐模型的全部评估参数：

SELECT
  *
FROM
  ML.EVALUATE(MODEL `09_recommendation_engine.recommender`,
    (
    SELECT * FROM `09_recommendation_engine.product_visits`));

此查询的结果显示在下图中：

图 9.9 – 从矩阵分解模型评估中提取的记录

可以通过从 BigQuery 导航菜单中选择 ML 模型，然后访问评估选项卡来获取相同的信息。

在下图中，您可以查看 BigQuery ML 模型的评估指标：

图 9.10 – 矩阵分解模型的评估选项卡

由于均方误差的值非常低，我们可以对我们的矩阵分解模型所取得的结果感到满意。

在本节中，我们学习了如何访问我们推荐模型的性能指标。现在，让我们使用推荐模型来找到最佳产品，向我们的客户推荐。

使用矩阵分解模型

在本节中，我们将测试矩阵分解模型，以获取我们网站用户的推荐产品。

要使用我们的 BigQuery ML 模型，我们将使用 ML.RECOMMEND 函数，同时指定预测的参数。

推荐引擎除了模型本身外，不需要任何额外的输入参数。如果模型有一个输入列，则模型将只返回输入行中的推荐。如果没有提供输入值，则模型将对原始数据集中用户和项目的每个组合应用预测。

ML.RECOMMEND 返回三列：

代表用户的列。在我们的实现中，这由fullVisitorID列标识。
专门针对推荐给特定用户的项目的领域。在我们的案例中，这由purchased_product_id列表示。
第三列代表在显式矩阵分解模型中的预测评分。如果模型是隐式的，就像在我们的案例中一样，该字段存储了推荐的预测置信度。

让我们执行以下查询，以实现一个包含由我们的矩阵分解模型生成的所有推荐的表：

CREATE OR REPLACE TABLE `09_recommendation_engine.product_recommendations` AS
    SELECT
      DISTINCT fullVisitorID, purchased_product_id, predicted_quantity_confidence
    FROM
      ML.RECOMMEND(MODEL`09_recommendation_engine.purchase_recommender`,
        (
        SELECT
          fullVisitorID
        FROM
          `09_recommendation_engine.product_purchases` ));

该查询创建了一个名为product_recommendations的新表，该表存储了用户和项目的DISTINCT对。在我们的案例中，这些对由fullVisitorID和purchased_product_id列组成。

对于每一对，ML.RECOMMEND函数还返回一个预测置信度，表示特定用户对电子商务目录中的产品感兴趣的概率。

现在我们已经得到了推荐引擎的输出，让我们学习如何从业务角度使用这些数据。

提取业务结论

现在我们已经应用了 BigQuery ML 模型，让我们学习如何从业务角度使用生成的结果来提高我们的销售策略的有效性。

从product_recommendations表中，我们可以提取相关信息，我们可以使用这些信息来改进我们的营销活动或广告策略，然后针对更有可能购买特定产品的用户进行定位。

例如，通过执行以下查询，我们可以从我们的电子商务门户中提取出前100个最有可能购买特定产品的用户：

SELECT *
FROM
    `09_recommendation_engine.product_recommendations`
ORDER BY predicted_quantity_confidence DESC
LIMIT 100;

执行此 SQL 语句返回以下结果：

![图 9.11 – 最有可能购买特定产品的客户

图 9.11 – 最有可能购买特定产品的客户

我们刚刚提取的列表可以发送到我们的营销办公室，以创建定制营销活动。或者，它也可以用于我们的电子商务门户，为特定注册客户推荐最有趣的产品。

摘要

在本章中，我们基于矩阵分解算法构建了一个推荐引擎。在介绍了业务场景之后，我们发现了矩阵分解是什么以及显式模型和隐式模型之间的区别。在深入数据探索之前，我们启用了 BigQuery Flex Slots，这对于训练这类机器学习算法是必要的。

然后，我们对 Google 从 Google Merchandise 电子商务门户收集的样本数据进行了分析和数据准备步骤。在这里，我们专注于构建我们的 BigQuery ML 模型所必需的字段。

接下来，我们创建了我们的训练表，其中包括每个用户所做的购买，以及每个产品的相关数量。

之后，我们在准备好的数据上训练了我们的矩阵分解模型。当模型训练完成后，我们使用 SQL 代码和 BigQuery UI 评估了其关键性能指标。

最后，我们使用我们新的矩阵分解模型生成了一些推荐，并提取了一份 100 名客户的清单，这些客户有很高的购买产品组合的倾向。

在下一章中，我们将介绍用于预测二元值的 XGBoost 算法。

进一步资源

Google Analytics 360 公共数据集: console.cloud.google.com/marketplace/product/obfuscated-ga360-data/obfuscated-ga360-data
BigQuery ML 创建模型: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create
BigQuery ML 评估模型: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
BigQuery ML 推荐: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-recommend
BigQuery ML 显式矩阵分解示例: cloud.google.com/bigquery-ml/docs/bigqueryml-mf-explicit-tutorial
BigQuery ML 隐式矩阵分解示例: cloud.google.com/bigquery-ml/docs/bigqueryml-mf-implicit-tutorial#implicit-model

第十章：使用 XGBoost 预测布尔值

极端梯度提升（XGBoost）是数据科学家可以利用来解决复杂用例的最强大的机器学习（ML）库之一。它最初是一个研究项目，第一个版本于 2014 年发布。由于其功能和可移植性，这个机器学习库的受欢迎程度迅速增长。实际上，它被用于重要的 Kaggle 机器学习竞赛，并且现在可用于不同的编程语言和不同的操作系统。

这个库可以用来解决不同的机器学习（ML）问题，并且专门为结构化数据设计。XGBoost 也最近被发布用于 BigQuery ML。多亏了这项技术，BigQuery 用户现在可以使用这个库实现分类和回归机器学习模型。

在本章中，我们将看到实现 XGBoost 分类模型的所有必要阶段，以便根据其特征将纽约市的树木分类到不同的物种。

使用 BigQuery ML SQL 语法，我们将探讨以下主题：

介绍业务场景
发现 XGBoost 增强树分类模型
探索和理解数据集
训练 XGBoost 分类模型
评估 XGBoost 分类模型
使用 XGBoost 分类模型
绘制商业结论

技术要求

本章要求您能够访问网络浏览器，并能够利用以下资源：

一个 Google Cloud Platform（GCP）账户以访问 Google Cloud 控制台
一个 GCP 项目来托管 BigQuery 数据集

现在我们已经满足了技术要求，让我们深入分析和开发我们的 BigQuery ML XGBoost 分类模型。

查看以下视频以查看代码的实际应用：bit.ly/3ujnzH3

介绍业务场景

在本节中，我们将介绍将使用 XGBoost 分类算法解决的业务场景。

业务场景与在第六章中介绍和使用的用例非常相似，使用多类逻辑回归对树木进行分类。在本章中，我们将使用相同的数据集，但将应用更先进的机器学习算法。

我们可以总结并记住，机器学习模型的目标是自动根据纽约市树木的特征，如位置、大小和健康状况，将它们分类到不同的物种。

正如我们在第九章中做的，通过矩阵分解建议合适的产品，我们可以只关注城市中存在的五种最常见的树木物种。

现在我们已经解释并理解了业务场景，让我们看看我们可以用来根据特征自动分类树木的机器学习技术。

发现 XGBoost 提升树分类模型

在本节中，我们将了解 XGBoost 提升树分类模型是什么，以及我们将理解哪些分类用例可以使用这个机器学习算法来解决。

XGBoost 是一个开源库，为不同的语言提供了一个可移植的梯度提升框架。XGBoost 库适用于不同的编程语言，如 C++、Java、Python、R 和 Scala，并且可以在不同的操作系统上运行。XGBoost 用于处理监督学习用例，其中我们使用标记的训练数据来预测目标变量。

XGBoost 在机器学习社区中的普及度逐年增长，因为它经常是许多在机器学习竞赛中获胜团队的选项，例如 2016 年的Kaggle - 高能物理与机器学习奖。

XGBoost 提升树的分类能力基于使用多个决策树来分类数据，从而实现预测。

在以下图表中，你可以看到一个简单的表示用于分类动物的决策树：

图 10.1 – 决策树的表示

XGBoost 分类模型可以回答与多类逻辑回归相同的问题，例如以下问题：

我的客户的评论是中立、正面还是负面？
我的客户属于金、银还是铜级别？
特定客户的流失概率是高、中还是低？
图像识别算法识别的是猫、狗、老鼠还是牛？

在我们的业务场景中，我们可以利用 XGBoost 提升树分类模型将纽约市的树木分为五种不同的物种。实际上，我们对根据每棵树的特征预测物种感兴趣。

在 XGBoost 算法的训练阶段，机器学习模型试图找到为每棵树分配的最佳值，以最小化最终的误差指标。

训练完成后，我们将比较这个模型的结果与我们之前在第六章，“使用多类逻辑回归分类树木”中得到的成果。

现在我们已经学习了 XGBoost 提升树算法的基础知识，是时候看看我们将用于构建我们的机器学习模型的数据集了。

探索和理解数据集

在本节中，我们将分析和准备用于我们用例的数据集。我们将从一些数据质量检查开始，然后我们将数据分割成训练、评估和测试表。

由于数据集已经在第六章，使用多类逻辑回归对树木进行分类中使用过，因此我们不会从开始分析。相反，我们将专注于我们业务场景中最相关的查询。

检查数据质量

为了开始我们的数据探索并进行数据质量检查，我们需要执行以下操作：

登录我们的 Google Cloud 控制台，并通过导航菜单访问BigQuery 用户界面（UI）。
在第二章，设置您的 GCP 和 BigQuery 环境中创建的项目下创建一个新的数据集。对于此用例，我们将创建一个名为10_nyc_trees_xgboost的数据集，并使用默认选项。
首先，让我们通过执行以下查询来检查所有记录在spc_latin字段中是否包含有效的值：
```
SELECT  COUNT(*)
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         spc_latin is NULL;
```
如以下屏幕截图所示，存在spc_latin列。这些记录将在训练阶段被过滤掉：

![图 10.2 – 查询结果显示应过滤掉一些记录

图 10.2 – 查询结果显示应过滤掉一些记录
在此第一次检查之后，我们需要验证是否有任何潜在的特征由NULL值表示。由于sidewalk和health字段中存在NULL值，我们将运行以下COUNT查询以检查三条记录。尽管数量很少，我们将在以下查询中过滤掉这些记录，以仅使用有意义的记录。

然后，我们可以从 BigQuery 公共数据集中提取最常见的五种树种。让我们执行以下查询：

SELECT   spc_latin,
         COUNT(*) total
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         spc_latin is NOT NULL
         AND zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
GROUP BY
         spc_latin
ORDER BY
         total desc
LIMIT 5;

查询将total计算为每个spc_latin字段记录的数量。使用ORDER BY子句按total字段从大到小的值排序结果。然后，使用LIMIT 5子句仅返回前五条记录。

在以下屏幕截图中，您可以查看查询结果，该结果显示了数据集中最常见的五种树种：

![图 10.3 – 数据集中最常见的树种

图 10.3 – 数据集中最常见的树种

为了将这些五种树种实体化到表中，让我们执行以下代码来创建一个名为10_nyc_trees_xgboost.top5_species的表：

CREATE OR REPLACE TABLE `10_nyc_trees_xgboost.top5_species` AS
      SELECT   spc_latin,
         COUNT(*) total
      FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
      WHERE
               spc_latin is NOT NULL
               AND zip_city is NOT NULL
               AND tree_dbh is NOT NULL
               AND boroname is NOT NULL
               AND nta_name is NOT NULL
               AND health is NOT NULL
               AND sidewalk is NOT NULL
      GROUP BY
               spc_latin
      ORDER BY
               total desc
      LIMIT 5;

与之前第 5 步中执行的查询的唯一区别在于使用了CREATE OR REPLACE TABLE关键字，这些关键字被用来将查询的结果实体化到新表中。

在本节中，我们已经分析了 BigQuery 公共数据集的数据质量。现在，让我们开始将其分割成三个不同的表，用于训练、评估和分类阶段。

分割数据集

在实现我们的 XGBoost 分类模型之前，让我们根据机器学习开发生命周期的主要阶段来分割我们的数据集：训练、评估和使用。为了将记录随机分成三个不同的表格，我们将在tree_id数值字段上使用MOD函数。按照以下步骤操作：

首先，让我们创建一个包含训练数据集的表格。为此，我们执行以下 SQL 语句：
```
CREATE OR REPLACE TABLE `10_nyc_trees_xgboost.training_table` AS 
SELECT  *
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
         AND spc_latin in 
         (SELECT spc_latin from `10_nyc_trees_xgboost.top5_species`) 
         AND MOD(tree_id,11)<=8; 
```
查询创建了一个包含原始数据集中所有列的10_nyc_trees_xgboost.training_table表格，通过SELECT *语句应用了所有必要的过滤器，以获取spc_latin标签和所有其他特征的空值。

使用IN子句，training_table将只包含与数据集中我们已识别的前五种最常见的物种相关的记录。

查询的最后一条语句，带有MOD(tree_id,11)<=8子句，使我们能够从整个数据集中仅选择 80%的记录。MOD代表模，返回tree_id除以 11 的余数。通过使用小于或等于运算符（<=），我们大约提取了整个数据集的 80%。

采用类似的方法，我们可以创建一个名为10_nyc_trees_xgboost.evaluation_table的表格，该表格将用于评估我们的机器学习模型。让我们执行以下CREATE TABLE语句：

CREATE OR REPLACE TABLE `10_nyc_trees_xgboost.evaluation_table` AS 
SELECT  *
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
         AND spc_latin in 
         (SELECT spc_latin from `06_nyc_trees.top5_species`) 
         AND MOD(tree_id,11)=9;

与我们创建训练表时的情况相反，对于evaluation_table表，我们通过应用MOD(tree_id,11)=9过滤器，仅从整个数据集中选择 10%的记录。

最后，我们将执行以下 SQL 语句以创建一个名为10_nyc_trees_xgboost.classification_table的表格，该表格将用于应用我们的 XGBoost 分类模型：

CREATE OR REPLACE TABLE `10_nyc_trees_xgboost.classification_table` AS 
SELECT  *
FROM    `bigquery-public-data.new_york_trees.tree_census_2015`
WHERE
         zip_city is NOT NULL
         AND tree_dbh is NOT NULL
         AND boroname is NOT NULL
         AND nta_name is NOT NULL
         AND health is NOT NULL
         AND sidewalk is NOT NULL
         AND spc_latin in 
         (SELECT spc_latin from `10_nyc_trees_xgboost.top5_species`) 
         AND MOD(tree_id,11)=10;

这个新表格与之前的表格非常相似，但多亏了MOD函数，它将包含数据集剩余的 10%。

在本节中，我们分析了包含纽约市树木信息的数据集，对数据进行了一些数据质量检查以排除空值，并分割了数据集，重点关注最常见的五种物种。现在我们已经完成了准备工作，是时候继续前进并开始训练我们的 BigQuery ML 模型了。

训练 XGBoost 分类模型

现在我们已经将数据集分割成多个表格以支持机器学习模型生命周期的不同阶段，让我们专注于训练我们的 XGBoost 分类模型。按照以下步骤操作：

让我们从训练我们的第一个机器学习模型xgboost_classification_model_version_1开始，如下所示：
```
CREATE OR REPLACE MODEL `10_nyc_trees_xgboost.xgboost_classification_model_version_1`
OPTIONS
  ( MODEL_TYPE='BOOSTED_TREE_CLASSIFIER',
    BOOSTER_TYPE = 'GBTREE',
    NUM_PARALLEL_TREE = 1,
    MAX_ITERATIONS = 50,
    TREE_METHOD = 'HIST',
    EARLY_STOP = FALSE,
    AUTO_CLASS_WEIGHTS=TRUE
  ) AS
SELECT
  zip_city,
  tree_dbh,
  spc_latin as label
FROM
  `10_nyc_trees_xgboost.training_table` ;
```
在这个 BigQuery ML 语句中，我们可以看到使用CREATE OR REPLACE MODEL关键字来启动模型的训练。这些关键字后面跟着机器学习模型的标识符。

在标识符之后，我们可以注意到一个OPTIONS子句。对于MODEL_TYPE，我们选择了BOOSTED_TREE_CLASSIFIER选项，这允许我们构建 XGBoost 分类模型。BOOSTER_TYPE = 'GBTREE'子句被认为是训练 XGBoost 提升树模型的默认选项。

为了限制训练的复杂性和资源消耗，我们选择仅通过NUM_PARALLEL_TREE = 1子句并行训练一棵树，并使用MAX_ITERATIONS在50次迭代后停止训练。

XGBoost 文档中建议对于大型数据集使用HIST参数，并使用EARLY_STOP = FALSE子句来防止在第一次迭代后停止训练阶段。

最后一个选项，AUTO_CLASS_WEIGHTS=TRUE，用于平衡权重——在数据集不平衡的情况下——以及一些可能比其他树种更频繁出现的树种。

这个模型的第一版本试图预测每棵树的物种，仅利用树木种植地的zip_city代码和树木的直径tree_dbh。
训练结束后，我们可以从 BigQuery 导航菜单中访问机器学习模型，查看模型的性能。选择评估选项卡，我们可以看到ROC AUC值。在这种情况下，该值为0.7775，如下面的截图所示：

图 10.4 – XGBoost 分类模型的评估指标

在相同的评估选项卡中，我们还可以可视化混淆矩阵，该矩阵显示了预测值与实际值相等多少次，如下面的截图所示：

图 10.5 – 评估选项卡显示了 XGBoost 分类模型的混淆矩阵
让我们尝试通过添加有助于将树木分类为不同物种的特征来改进我们的机器学习模型。让我们通过运行以下代码来训练我们 BigQuery 机器学习模型的第二个版本：
```
CREATE OR REPLACE MODEL `10_nyc_trees_xgboost.xgboost_classification_model_version_2`
OPTIONS
  ( MODEL_TYPE='BOOSTED_TREE_CLASSIFIER',
    BOOSTER_TYPE = 'GBTREE',
    NUM_PARALLEL_TREE = 1,
    MAX_ITERATIONS = 50,
    TREE_METHOD = 'HIST',
    EARLY_STOP = FALSE,
    AUTO_CLASS_WEIGHTS=TRUE
  ) AS
SELECT
  zip_city,
  tree_dbh,
  boroname,
  nta_name,
  spc_latin as label
FROM
  `10_nyc_trees_xgboost.training_table` ;
```
与之前的步骤 1的第一次尝试相比，我们包括了额外的特征。事实上，我们将包含在boroname字段和nta_name字段中的区名添加到特征中，这些字段提供了与树木在城市中位置相关的更具体信息。

执行 SQL 语句后，让我们访问新模型的评估选项卡，看看我们是否提高了其性能。查看ROC AUC值为0.80，我们可以看到与第一个版本相比，我们模型的性能略有提高。

然后，我们将尝试向我们的机器学习模型添加与树木健康和其根系侵入性相关的其他特征，这些侵入性可能会损坏相邻的人行道，如下所示：

CREATE OR REPLACE MODEL `10_nyc_trees_xgboost.xgboost_classification_model_version_3`
OPTIONS
  ( MODEL_TYPE='BOOSTED_TREE_CLASSIFIER',
    BOOSTER_TYPE = 'GBTREE',
    NUM_PARALLEL_TREE = 5,
    MAX_ITERATIONS = 50,
    TREE_METHOD = 'HIST',
    EARLY_STOP = FALSE,
    AUTO_CLASS_WEIGHTS=TRUE
  ) AS
SELECT
  zip_city,
  tree_dbh,
  boroname,
  nta_name,
  health,
  sidewalk,
  spc_latin as label
FROM
  `10_nyc_trees_xgboost.training_table`;

与之前的 ML 模型相比，xgboost_classification_model_version_3 模型包含一个 health 字段，用于描述我们树木的健康状况，以及一个 sidewalk 字段，用于指定树木的根是否损坏相邻的人行道。

在 BigQuery UI 的评估选项卡中查看我们最后 ML 模型的性能，我们可以注意到我们在 ROC AUC 方面又取得了提高，值为 0.8121。

在本节中，我们通过尝试在我们的数据集中使用不同的特征创建了不同的 ML 模型。在接下来的步骤中，我们将使用具有最高 xgboost_classification_model_version_3 的模型。

现在，让我们开始在评估数据集上对 XGBoost 分类模型进行评估阶段。

评估 XGBoost 分类模型

为了评估我们的 BigQuery ML 模型，我们将使用 ML.EVALUATE 函数以及我们专门创建的作为评估数据集的表格。

以下查询将告诉我们模型是否过度拟合，或者是否也能在新数据上表现良好：

SELECT
  roc_auc,
  CASE
    WHEN roc_auc > .9 THEN 'EXCELLENT'
    WHEN roc_auc > .8 THEN 'VERY GOOD'
    WHEN roc_auc > .7 THEN 'GOOD'
    WHEN roc_auc > .6 THEN 'FINE'
    WHEN roc_auc > .5 THEN 'NEEDS IMPROVEMENTS'
  ELSE
  'POOR'
END
  AS model_quality
FROM 
  ML.EVALUATE(MODEL `10_nyc_trees_xgboost.xgboost_classification_model_version_3`,
    (
    SELECT
       zip_city,
       tree_dbh,
       boroname,
       nta_name,
       health,
       sidewalk,
       spc_latin as label
     FROM `10_nyc_trees_xgboost.evaluation_table`));

SELECT 语句提取了 ML.EVALUATE 函数返回的 roc_auc 值，并提供了对模型质量的清晰描述，从 'POOR' 开始，可以达到 'EXCELLENT' 等级，经过一些中间阶段，如 'NEEDS IMPROVEMENTS' 和 'GOOD'。

执行查询，我们可以看到分数是 非常好，如下面的截图所示：

![图 10.6 – 评估阶段为我们的 BigQuery ML 模型的质量返回了“非常好”]

图 10.6 – 评估阶段为我们的 BigQuery ML 模型的质量返回了“非常好”

现在我们已经评估了我们的 ML 模型，让我们看看我们如何将其应用于其他记录以获得树木的分类。

使用 XGBoost 分类模型

在本节中，我们将使用 ML 模型根据树木的特征将树木分类到五种不同的物种。

为了测试我们的 BigQuery ML 模型，我们将在 classification_table 表上使用 ML.PREDICT 函数，如下所示：

SELECT
  tree_id,
  actual_label,
  predicted_label_probs,
  predicted_label
FROM
  ML.PREDICT (MODEL `10_nyc_trees_xgboost.xgboost_classification_model_version_3`,
    (
    SELECT
       tree_id,
       zip_city,
       tree_dbh,
       boroname,
       nta_name,
       health,
       sidewalk,
       spc_latin as actual_label
    FROM
      `10_nyc_trees_xgboost.classification_table`
     )
  );

查询由一个 SELECT 语句组成，该语句提取 tree_id 值、树木的实际物种、每个预测物种的概率以及预测物种。

在下面的截图中，你可以看到查询执行的结果：

![图 10.7 – 查询输出显示了实际标签和预测标签]

与相关的概率

图 10.7 – 查询输出显示了实际标签和预测标签以及相关的概率

在前面截图显示的两行中，标识为 283502 和 226929 的树木被很好地分类到 Acer platanoides 物种，置信度为 61%。

现在我们已经测试了我们的 BigQuery ML 模型，让我们通过比较 XGBoost 分类模型与在第六章中使用的逻辑回归的结果来做出一些最终考虑。

绘制业务结论

在本节中，我们将使用我们的 ML 模型，并了解 BigQuery ML 模型在classification_table表中能够将树木正确分类的次数。

让我们执行以下查询来计算预测物种与实际物种一致性的次数：

SELECT COUNT(*)
FROM (
      SELECT
        tree_id,
        actual_label,
        predicted_label_probs,
        predicted_label
      FROM
        ML.PREDICT (MODEL `10_nyc_trees_xgboost.xgboost_classification_model_version_3`,
          (
          SELECT
             tree_id,
             zip_city,
             tree_dbh,
             boroname,
             nta_name,
             health,
             sidewalk,
             spc_latin as actual_label
          FROM
            `10_nyc_trees_xgboost.classification_table`
           )
        )
)
WHERE
      actual_label = predicted_label;

为了计算这个值，我们通过仅过滤预测值等于实际值的行，引入了一个WHERE子句。

如以下截图所示，SELECT COUNT返回了14277条记录：

图 10.8 – 查询输出显示了分类模型预测正确物种的次数

在classification_table表中存储的 27,182 行数据中，我们可以说我们的模型在 52.52%的情况下将树木正确分类。

在以下表中，XGBoost 分类模型的结果与在第六章中应用的多元逻辑回归的结果进行了比较，使用多元逻辑回归对树木进行分类：

图 10.9 – XGBoost 分类模型和多类逻辑回归的比较

观察前面的表格，我们可以得出结论，为了将纽约市的树木分类到最常见的五种物种，与多元逻辑回归模型相比，XGBoost 分类模型能够实现更好的结果。

摘要

在本章中，我们实现了一个 XGBoost 分类模型。我们回忆了在第六章中已经使用的业务场景，使用多元逻辑回归对树木进行分类，基于自动分类纽约市树木的需求。之后，我们学习了 XGBoost 提升树分类模型的基础知识。

为了构建一个有效的模型，我们进行了数据质量检查，然后根据我们的需求将数据集分割成三个表：一个用于存放训练数据，第二个用于评估阶段，最后一个用于应用我们的分类模型。

在 BigQuery ML 模型的训练阶段，我们不断改进了 ML 模型的性能，使用 ROC AUC 作为关键性能指标（KPI）。

之后，我们评估了最佳 ML 模型在新的记录集上的表现，以避免任何过拟合，从而对我们 XGBoost 分类模型的高质量更加有信心。

最后，我们将我们的 BigQuery ML 模型应用于最后一批记录，根据它们的特征将树木分类到物种中。我们发现我们的 ML 模型在 52.52% 的情况下能够正确分类树木。然后，我们还比较了 XGBoost 模型的性能与我们在 第六章 中进行的多元逻辑回归训练，即 使用多元逻辑回归分类树木，并注意到 XGBoost 的性能超过了多元逻辑回归训练。

在下一章中，我们将学习关于高级 深度神经网络（DNNs），利用 BigQuery SQL 语法。

进一步资源

纽约市街道树木普查公共数据集：console.cloud.google.com/marketplace/product/city-of-new-york/nyc-tree-census
XGBoost 主页：xgboost.ai/
XGBoost 文档：xgboost.readthedocs.io/en/latest/index.html
CREATE MODEL 语句用于提升树模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-boosted-tree
ML.EVALUATE 函数：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
ML.PREDICT 函数：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-predict

第十一章：实现深度神经网络

深度神经网络（DNNs）是实现机器学习算法的最先进技术之一。它们在多种用例中广泛使用，并且可以被认为是日常生活中无处不在的。

当我们与虚拟助手互动，或使用移动应用程序进行自动翻译和图像识别时，我们正在利用使用大量音频和图像数据集训练的深度神经网络（DNNs）的能力。

在阅读本章后，您将能够使用 BigQuery ML 开发、评估和测试一个 DNN。在本章中，我们将看到使用 BigQuery ML 通过预测与纽约市自行车共享服务相关的租赁时长来实施 DNN 的所有必要阶段。

使用 BigQuery ML，我们将探讨以下主题：

介绍商业场景
发现 DNNs
准备数据集
训练 DNN 模型
评估 DNN 模型
使用 DNN 模型
提取业务结论

技术要求

本章要求您能够访问网络浏览器，并能够利用以下内容：

一个 GCP 账户以访问 Google Cloud Console
一个 GCP 项目来托管 BigQuery 数据集

现在我们已经准备好了技术要求，让我们深入分析和发展我们的 BigQuery ML DNN 模型。

查看以下视频以查看代码的实际应用：bit.ly/33lbq8A

介绍商业场景

在本节中，您将了解到将使用 DNN 技术处理的商业场景。

商业场景与在第四章中介绍和使用的用例非常相似，即使用线性回归预测数值。在这一章中，我们将使用与纽约市自行车共享服务相关的相同数据集，但我们将应用更先进的机器学习算法。

我们可以记住，机器学习模型的假设目标是预测自行车租赁的行程时间。预测值可以用于通过新的移动应用程序为自行车共享服务的客户提供更好的体验。利用预测的骑行时长，客户将得到到达特定目的地所需时间的明确指示，以及骑行成本的估计。

既然我们已经解释并理解了商业场景，让我们来看看我们可以使用的机器学习技术，以自动根据特征对树木进行分类。

发现 DNNs

在本节中，我们将学习什么是DNNs，并了解哪些回归和分类用例可以使用高级机器学习算法来管理。

人工神经网络（ANNs）是试图复制人脑的人工系统。它们受到生物神经网络的启发，由神经元和连接神经元的突触组成。人工网络中的每个神经元都是一个组件，它对输入应用特定的数学激活函数，并返回一个通过突触传递给下一个神经元的输出。在 ANNs 中，神经元通常组织在输入和输出之间的层中。

与线性模型不同，ANNs 旨在模拟输入和输出变量之间的非线性关系。

DNNs是由多个层组成的 ANNs，这些层位于输入和输出之间，通常是两层或更多。每个神经元的层被称为隐藏层，其功能是接受一系列输入信号，并将一系列输出信号返回给下一层。

在以下图中，我们可以看到 DNN 由三个输入变量、两个隐藏层和一个输出变量组成：

![图 11.1 – DNN 的示意图

![img/B16722_11_001.jpg]

图 11.1 – DNN 的示意图

网络中的每个神经元都对输入信号应用特定的函数，并将该函数的输出作为神经元的输出。训练 DNN 是一项专注于找到网络中每个神经元之间每个突触的正确权重的活动。

尽管如此，为了实现 DNNs 的潜力，我们需要重要的硬件资源，但使用这种技术实现的机器学习模型可以在典型的人脑任务中实现最佳结果。以下是一些例子：

语音识别：处理音频文件以识别语音中的单词，使其可读的能力。这种能力在智能手机的虚拟助手或接触中心应用程序中得到广泛应用。
图像和面部识别：在图片和视频中识别不同实体、动物或人物的可能性。这项技术特别有用，可以自动从图像和视频中提取见解，避免任何人工努力。
自然语言处理：广泛用于分析和检索自由文本中的信息，以及分析消息的情感。例如，这类算法被用于自动识别社交网络中的政策违规，或在产品评论中评估情感。

既然我们已经了解了 DNNs 是什么，让我们关注 BigQuery ML 如何提供这些强大的算法。

BigQuery ML 中的 DNNs

在本节中，我们将学习 BigQuery ML 提供的创建 DNN 模型模型类型选项。

BigQuery ML 允许您创建两种不同类型的深度神经网络（DNNs）：

DNNClassifier：此算法可用于将事件、对象或实体分类到有限数量的离散类别中。
DNNRegressor：这种模型与之前的模型类似，区别在于它返回一个连续的结果。因此，它可以用来预测数值。

对于我们的业务场景，我们将使用DNNRegressor，因为我们的目标是预测一个连续值：自行车租赁的骑行时间。

根据我们的用例选择了要使用的 DNN 类型后，下一个选择将集中在每个神经元将应用于输入信号的功能。BigQuery ML 允许我们选择以下函数之一：

Rectified Linear Function (ReLU)：这是一个线性函数，如果输入值是正的，则返回输入值本身，否则返回零。
ReLU6：这与之前的函数类似，但最大输出值被限制为 6。这只是一个从不同函数的经验测试中得出的任意值。
Concatenated Rectified Linear Units (CReLU)：与之前的函数不同，它保留了负值。
Exponential Linear Unit (ELU)：这是一个指数函数，它倾向于更快地收敛到结果并产生更精确的输出。
Scaled Exponential Linear Unit (SELU)：这是 ELU 的演变，它添加了数学函数的自我归一化。
SIGMOID：这与一个阶梯函数类似，始终输出介于 0 和 1 之间的值。这个函数将非线性引入 DNN。
TANH：这与 sigmoid 函数类似，但返回的值介于-1 和 1 之间。

每个函数都有一些优点和缺点，并且应根据用例和训练数据集来选择，以实现最佳结果。对于我们的业务场景，我们将尝试使用这些函数中的一些来训练 DNN，并选择产生最佳结果的函数。

现在我们已经学习了 DNN 的基础知识和 BigQuery ML 通过其 SQL 界面提供的主要选项，让我们开始准备创建我们的机器学习模型所需的数据。

准备数据集

在开始 ML 实现之前，有必要分析和准备我们用例的数据。由于数据集已经在第四章中使用了，使用线性回归预测数值，我们将不会从头开始分析，但我们将专注于与我们用例相关的查询。

开始准备我们的数据，我们需要做以下事情：

登录 Google Cloud 控制台，并通过导航菜单访问BigQuery用户界面。
在第二章中创建的项目下创建一个新的数据集，设置您的 GCP 和 BigQuery 环境。对于这个用例，我们将使用默认选项创建数据集11_nyc_bike_sharing_dnn。

现在我们已经准备好创建包含训练数据集的表。让我们执行以下 SQL 语句：

CREATE OR REPLACE TABLE `11_nyc_bike_sharing_dnn.training_table` AS
              SELECT 
                   tripduration/60 tripduration,
                   start_station_name,
                   end_station_name,
                   IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR EXTRACT(DAYOFWEEK FROM starttime)=7, true, false) is_weekend,
                   EXTRACT(YEAR FROM starttime)-birth_year as age
              FROM
                    `bigquery-public-data.new_york_citibike.citibike_trips`
              WHERE 
                    (
                        (EXTRACT (YEAR FROM starttime)=2017 AND
                          (EXTRACT (MONTH FROM starttime)>=04 OR EXTRACT (MONTH FROM starttime)<=10))
                        OR (EXTRACT (YEAR FROM starttime)=2018 AND
                          (EXTRACT (MONTH FROM starttime)>=01 OR EXTRACT (MONTH FROM starttime)<=02))
                    )
                    AND (tripduration>=3*60 AND tripduration<=3*60*60)
                    AND  birth_year is not NULL
                    AND birth_year < 2007;

查询结果存储在新创建的表中，名为 `11_nyc_bike_sharing_dnn.training_table`，我们创建此表是为了支持我们用例的以下步骤。

SELECT 语句从 citibike_trips 表中提取字段并应用一些转换。tripduration 从秒转换为分钟。start_station_name 和 end_station_name 字段直接提取。使用 starttime，查询计算租赁是否发生在工作日或周末。最后，使用 starttime 和 birth_year 之间的差值计算顾客在骑行时的年龄。

正如我们在 第四章 中所做的那样，使用线性回归预测数值值，WHERE 子句允许我们仅考虑我们想要用于训练阶段的月份。对于训练数据集，时间范围从 2017 年 4 月到 2018 年 2 月。在相同的 WHERE 子句中，我们还应用了来自数据质量检查的过滤器。

在创建训练表之后，我们可以创建第二个表，专门用于记录将用于评估我们的机器学习模型的：

CREATE OR REPLACE TABLE  `11_nyc_bike_sharing_dnn.evaluation_table` AS
SELECT 
                   tripduration/60 tripduration,
                   start_station_name,
                   end_station_name,
                   IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR EXTRACT(DAYOFWEEK FROM starttime)=7, true, false) is_weekend,
                   EXTRACT(YEAR FROM starttime)-birth_year as age
               FROM
                    `bigquery-public-data.new_york_citibike.citibike_trips`
               WHERE 
                    (EXTRACT (YEAR FROM starttime)=2018 AND (EXTRACT (MONTH FROM starttime)=03 OR EXTRACT (MONTH FROM starttime)=04))
                    AND (tripduration>=3*60 AND tripduration<=3*60*60)
                    AND  birth_year is not NULL
                    AND birth_year < 2007;

查询与用于创建训练表的语句非常相似。唯一的区别是 WHERE 子句中选择的时期。对于 `11_nyc_bike_sharing_dnn.evaluation_table` 表，我们专注于之前从训练表中排除的 2018 年 3 月和 4 月的记录。

采用相同的方法，我们也可以创建用于测试我们的机器学习模型的表：

CREATE OR REPLACE TABLE  `11_nyc_bike_sharing_dnn.prediction_table` AS
              SELECT 
                   tripduration/60 tripduration,
                  start_station_name,
                   end_station_name,
                   IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR EXTRACT(DAYOFWEEK FROM starttime)=7, true, false) is_weekend,
                   EXTRACT(YEAR FROM starttime)-birth_year as age
              FROM
                    `bigquery-public-data.new_york_citibike.citibike_trips`
              WHERE 
                    EXTRACT (YEAR FROM starttime)=2018
                    AND EXTRACT (MONTH FROM starttime)=05
                     AND (tripduration>=3*60 AND tripduration<=3*60*60)
                    AND  birth_year is not NULL
                    AND birth_year < 2007;

查询应用了创建训练和评估表时使用的相同逻辑，但仅考虑了 2018 年 5 月的月份。

现在我们已经分割了数据集，并且明确了用于训练、评估和测试阶段的记录，让我们使用 BigQuery ML 训练我们的 DNN 模型。

训练 DNN 模型

既然我们已经将数据集分割成多个表以支持机器学习模型生命周期的不同阶段，让我们使用不同的激活函数来训练我们的深度神经网络（DNN）回归模型：

首先，我们可以通过使用 RELU 函数开始训练一个 DNN 模型。让我们执行以下 SQL 语句来创建机器学习模型 `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`：
```
CREATE OR REPLACE MODEL `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`
OPTIONS
  (model_type='DNN_REGRESSOR',
        ACTIVATION_FN = 'RELU') AS
SELECT
  start_station_name,
  end_station_name,
  is_weekend,
  age,
  tripduration as label
FROM
  `11_nyc_bike_sharing_dnn.training_table`;
```
在 SQL 语句中，我们可以注意到用于创建新模型的 CREATE OR REPLACE MODEL 关键字。这些关键字后面跟着由数据集和机器学习模型名称连接而成的模型标识符。

在这些第一行之后，我们发现 OPTIONS 关键字，其中指定了机器学习模型类型。由于我们试图预测连续字段 tripduration，我们选择了使用 DNN_REGRESSOR 作为 model_type。

在训练深度神经网络（DNN）期间，另一个重要的选项是应用于网络神经元的激活函数。对于这次尝试，我们使用最常见的一种函数：RELU。这个选择通过ACTIVATION_FN = 'RELU'子句来指定。

在OPTIONS之后，我们需要指定机器学习模型将要训练的记录集。由于我们已经在第四章中识别了相关字段，即使用线性回归预测数值，查询使用start_station_name、end_station_name、is_weekend和age作为 DNN 模型的特征。

使用关键词as label，我们指示 BigQuery ML 将tripduration作为我们机器学习模型的标签。作为替代，我们可以在包含关键词INPUT_LABEL_COLS的OPTIONS列表中包含标签。

由于 DNN 是高级且复杂的模型，在收敛到解决方案并生成机器学习模型之前可能需要几分钟。
在 SQL 查询执行结束时，我们可以在 BigQuery 导航菜单中选择trip_duration_by_stations_day_age_relu DNN 模型，并点击tripduration。

如以下截图所示，平均绝对误差非常接近 4 分钟：

图 11.2 – 评估选项卡显示了 DNN 模型的一些关键性能指标
作为第二次尝试，我们可以尝试更改神经网络中的激活函数，看看是否可以进一步提高第一个模型的表现。让我们使用CRELU激活函数运行以下 SQL 语句：
```
CREATE OR REPLACE MODEL `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_crelu`
OPTIONS
  (model_type='DNN_REGRESSOR',
        ACTIVATION_FN = 'CRELU') AS
SELECT
  start_station_name,
  end_station_name,
  is_weekend,
  age,
  tripduration as label
FROM
  `11_nyc_bike_sharing_dnn.training_table`;
```
训练 DNN 的查询11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_crelu与我们第一次尝试中使用的 SQL 语句非常相似。唯一的区别在于OPTIONS中指定的不同激活函数。使用ACTIVATION_FN = 'CRELU'子句，我们在网络神经元中使用CRELU函数。

训练查询的执行将需要几分钟才能完成。
在 SQL 查询执行结束时，我们可以在 BigQuery 导航菜单中选择trip_duration_by_stations_day_age_crelu DNN 模型，并在评估选项卡中可视化性能。

如以下截图所示，平均绝对误差几乎接近 4 分钟：

图 11.3 – 评估选项卡显示了 DNN 模型的一些关键性能指标

现在，让我们开始评估在本节中训练的 DNN。

评估 DNN 模型

为了评估我们的 BigQuery ML DNNs，我们将使用 ML.EVALUATE 函数以及我们专门创建的作为评估数据集的表格：

首先，我们可以开始评估模型 `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`。让我们运行以下查询：
```
SELECT
  *
FROM
  ML.EVALUATE(MODEL `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`,
    (
    SELECT
          start_station_name,
          end_station_name,
          is_weekend,
          age,
          tripduration as label
    FROM
           `11_nyc_bike_sharing_dnn.evaluation_table` ));
```
在 SQL 语句中，我们可以注意到使用了关键字 ML.EVALUATE 来评估 DNN。评估函数后面跟着 BigQuery ML 模型的标识符：`11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`。

评估函数应用于提取表 `11_nyc_bike_sharing_dnn.evaluation_table` 中所有字段的 SELECT 语句。

几秒钟后，我们可以看到以下截图所示的评估阶段的结果：

图 11.4 – 评估 SQL 语句的结果

我们可以注意到 平均绝对误差 值与我们训练阶段达到的值并没有太大的不同。我们可以说，我们的模型没有受到过拟合的影响，并且在评估数据集的新记录上表现良好。
让我们在第二个模型 `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_crelu` 上应用相同的评估逻辑。为了评估这个 BigQuery ML 模型的性能，我们运行以下 SQL 语句：
```
SELECT
  *
FROM
  ML.EVALUATE(MODEL `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_crelu`,
    (
    SELECT
          start_station_name,
          end_station_name,
          is_weekend,
          age,
          tripduration as label
    FROM
           `11_nyc_bike_sharing_dnn.evaluation_table` ));
```
最后一个查询与上一个查询的唯一区别在于受评估的 DNN 的名称：`11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_crelu`。

几秒钟后，我们将看到以下截图所示的评估结果：

图 11.5 – 评估 SQL 语句的结果

此外，在这种情况下，平均绝对误差 值与我们训练阶段达到的 4 分钟值相差不远。这个模型没有受到过拟合的影响，并且与之前的模型相似。

现在我们已经评估了我们的 BigQuery ML 模型，让我们看看如何使用基于 ReLU 激活函数的 DNN 来预测自行车租赁的持续时间。

使用 DNN 模型

在本节中，我们将使用基于 ReLU 函数的 DNN 模型，并训练它利用 BigQuery ML 功能来预测纽约市自行车共享公司的骑行持续时间。

为了测试我们的 DNN，我们将在 prediction_table 表上使用 ML.PREDICT 函数。让我们运行以下 SQL 语句：

SELECT
   tripduration as actual_duration,
   predicted_label as predicted_duration,
   ABS(tripduration - predicted_label) difference_in_min
FROM
  ML.PREDICT(MODEL `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`,
    (
    SELECT
         start_station_name,
          end_station_name,
          is_weekend,
          age,
          tripduration
    FROM
           `11_nyc_bike_sharing_dnn.prediction_table`
    ))
    order by  difference_in_min asc;

查询语句由一个 SELECT 关键字组成，它提取了租赁的实际和预测持续时间。它计算了分钟数的差异，并按分钟数的最小差异到最大差异排序。为了计算差异，我们使用了 ABS 函数，该函数提取了数字的绝对值。

ML.PREDICT 函数应用于 SELECT 语句，该语句从 prediction_table 中提取特征和实际持续时间。这个最后字段仅用于与预测值进行比较，并且不用于 DNN 返回预测。

在以下屏幕截图，你可以看到查询执行的结果：

图 11.6 – 查询输出显示了实际和预测标签，差异以分钟表示

现在我们已经测试了我们的 BigQuery ML 模型，让我们来看看一些最终的考虑因素，比较基于 CReLU 激活函数的 DNN 结果与我们在 第四章 中使用线性回归所取得的结果，使用线性回归预测数值值。

提炼商业结论

在本节中，我们将应用我们的 DNN 模型，并了解 BigQuery ML 模型能够预测接近实际租赁持续时间的次数。

我们将在之前的查询中添加一个父 SELECT COUNT 语句，以计算实际持续时间与预测值之间的差异小于 15 分钟的次数。

让我们执行以下查询来计算预测的行程持续时间与实际值相差较远的情况发生的频率：

SELECT COUNT (*)
FROM (
SELECT
   tripduration as actual_duration,
   predicted_label as predicted_duration,
   ABS(tripduration - predicted_label) difference_in_min
FROM
  ML.PREDICT(MODEL  `11_nyc_bike_sharing_dnn.trip_duration_by_stations_day_age_relu`,
    (
    SELECT
          start_station_name,
          end_station_name,
          is_weekend,
          age,
          tripduration
    FROM
           `11_nyc_bike_sharing_dnn.prediction_table`
    ))
    order by  difference_in_min asc) where difference_in_min<=15 ;

SELECT COUNT 查询的结果返回了 1,640,446 个预测值，预测值与实际值之间的差异小于 15 分钟。

考虑到 prediction_table 表的总大小为 1,728,078，我们可以说在 94.92% 的情况下，我们的 DNN 能够预测行程持续时间，差异小于 15 分钟。

现在，我们可以将我们用 DNN 达到的最佳结果与我们在 第四章 中使用线性回归模型所达到的性能进行比较，使用线性回归预测数值值。

深度神经网络与线性模型

在以下表格中，基于 CReLU 激活函数的 DNN 模型的结果与线性回归模型进行了比较：

图 11.7 – DNN 模型与线性回归模型的比较

通过查看前面的表格，我们可以得出结论，为了预测纽约市自行车共享服务的行程持续时间，使用 DNN 模型可以获得最佳结果。因此，我们可以建议使用 DNN 模型向公司的客户提供行程持续时间建议。使用 DNN，我们可以将平均绝对误差降低超过 43%。在某些行业中，这样的改进可能为公司带来巨大的竞争优势。

摘要

在本章中，我们实现了两个 DNN。我们回顾了在第四章中已经介绍过的业务场景，即使用线性回归预测数值。用例基于预测纽约市自行车共享服务的租赁时间的需求。之后，我们学习了 DNN 的基础知识以及可以用于实现网络中神经元的各种激活函数。

我们将 BigQuery 公共数据集分割成三个不同的表：一个用于存放训练数据，第二个用于评估阶段，最后一个用于测试我们的 DNN 模型。

在 BigQuery ML 模型的训练阶段，我们测试了两种不同的激活函数，ReLU和CReLU，通过比较平均绝对误差来找到最佳的一个。

之后，我们在一组新的记录上评估了我们的深度神经网络（DNN）模型，以防止过拟合，并对我们 BigQuery ML 模型的高质量更有信心。

最后，我们将基于ReLU函数的模型应用于最后一批记录，以预测每辆自行车租赁的行程时长。我们发现我们的 BigQuery ML 模型能够预测超过 94%的租赁的行程时长，其预测值与实际行程时长相差不超过 15 分钟。

最后，我们还比较了 DNN 模型与在第四章中实现的线性回归结果。我们注意到 DNN 优于线性回归，将平均绝对误差降低了 43%，并且能够为我们业务场景实现更好的结果。

在下一章中，我们将学习如何使用 BigQuery ML 与 GCP AI 笔记本结合使用。

进一步资源

纽约市自行车共享公共数据集：console.cloud.google.com/marketplace/product/city-of-new-york/nyc-citi-bike
BigQuery ML 创建模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-dnn-models
BigQuery ML 评估模型：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
BigQuery ML 预测：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-predict

第四部分：使用 GCP 进一步扩展您的 ML 能力

在本节中，详细解释和展示了 BigQuery ML 与其他 GCP 组件的所有集成。

本节包含以下章节：

第十二章, 在 AI 笔记本中使用 BigQuery ML
第十三章, 使用 BigQuery ML 运行 TensorFlow 模型
第十四章, BigQuery ML 技巧和最佳实践

第十二章：使用 AI 笔记本与 BigQuery ML

对于数据科学家和机器学习工程师来说，笔记本是一个基本的生产力工具。笔记本允许我们与计算资源进行交互，因为我们可以使用它们来编写和执行代码，可视化结果，并与其他数据科学家分享成果。数据工程师、数据科学家和机器学习工程师在将代码部署到生产环境之前进行实验和探索数据。他们利用笔记本，因为它们提供了一个灵活且敏捷的环境来开发和测试。

在本章中，我们将学习 AI 平台笔记本 是什么，如何配置笔记本环境，以及如何使用它来开发 BigQuery ML 模型。

我们将从了解笔记本的基础知识开始，然后开始进行一些与 Google Cloud Platform（GCP）的动手实践。

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

发现 AI 平台笔记本
在笔记本中实现 BigQuery ML 模型

技术要求

本章要求您能够访问网络浏览器，并可以利用以下资源：

一个 GCP 账户以访问 Google Cloud Console
一个用于托管 BigQuery 数据集的 GCP 项目

现在我们已经了解了本章的技术要求，让我们学习如何使用 AI 平台笔记本开发机器学习模型。

查看以下视频以了解代码的实际应用：bit.ly/2QVZ1oY

发现 AI 平台笔记本

在本节中，我们将学习 AI 平台笔记本 是什么以及它能够提供的优势。

AI 平台笔记本 是一个完全托管的服务，允许数据工程师和数据科学家使用 JupyterLab 开发环境。此服务允许我们开发、评估、测试和部署机器学习模型。

JupyterLab 是由 Project Jupyter 开发和维护的一个面向数据科学家的网络工具（jupyter.org/about）。该项目的目标是开发开源软件和标准，为不同的编程语言提供独特的界面。

使用 AI 平台笔记本与 JupyterLab 可以带来几个优势：

我们可以轻松设置预配置的机器学习环境，其中包含最重要的和最有用的 ML 库，如 TensorFlow、Keras、PyTorch 等。
我们可以通过根据我们的需求增加硬件资源的大小来利用云的可扩展性。例如，我们可以通过增加 RAM 或添加 图形处理单元（GPU）来提高我们笔记本的性能。
我们可以在不进行任何额外配置的情况下从我们的笔记本访问其他 Google Cloud 服务。从 AI 平台笔记本，我们可以轻松利用 BigQuery、Dataflow 和 Dataproc。
我们可以将我们的开发环境与代码版本控制应用程序（如 Git）集成。
我们可以轻松地将我们的笔记本与同事或朋友分享，从而加快协作速度并提高生产力。

在以下屏幕截图中，您可以看到 JupyterLab 笔记本的网页界面：

图 12.1 – JupyterLab 的网页界面

笔记本可以包含描述性内容、代码块和结果。它由一系列可执行的单元格组成。有两种类型的单元格：

代码单元格：包含可执行的代码以运行。它们的执行结果将在代码之后立即可视化。
Markdown 单元格：包含 HTML 代码以生成标题、列表和格式化文本。这些单元格通常用于描述代码，并使整个笔记本易于阅读和理解。

让我们进入下一节！

AI 平台笔记本定价

在本节中，您将了解 AI 笔记本的价格是如何计算并记入您的 Google Cloud 账户的。

由于 JupyterLab 软件是开源的，当您使用 AI 平台笔记本时，您只需为消耗的 Google Cloud 资源付费。

要开始使用 AI 平台笔记本，您需要支付以下费用：

Google Compute Engine（GCE），用于部署您的开发环境的虚拟机。GCE 根据您配置的虚拟 CPU 数量、内存和磁盘收费。
任何可以从笔记本调用的其他服务，例如 BigQuery。

小贴士

记得在您不使用 AI 平台笔记本时关闭托管它的 GCE。如果虚拟机保持激活状态，即使您实际上没有使用，您也将继续为这些资源付费。

现在，我们已经了解了 AI 平台笔记本是什么以及为什么在开发机器学习模型时它可能很有用，在下一节中，我们将了解如何配置我们的第一个笔记本。

配置第一个笔记本

在本节中，我们将设置我们的第一个 AI 平台笔记本，该笔记本将用于训练、评估和测试 BigQuery ML 模型。

首先，让我们浏览控制台的导航菜单，直到我们找到AI 平台（统一）项。从子菜单中选择笔记本：

图 12.2 – 控制菜单中的 AI 平台笔记本
如果这是我们第一次访问此服务，我们将被要求启用 API。我们可以点击蓝色的启用按钮开始使用该服务：

图 12.3 – 启用笔记本 API
几分钟后，服务将被启用并准备好使用。我们将被重定向到一个包含我们刚刚启用的 API 统计信息的网页：

图 12.4 – Notebooks API 的统计信息
再次从控制台的导航菜单中选择 Notebooks 项，我们将访问专门用于 AI 平台笔记本的页面。通过选择蓝色 创建实例 按钮，我们将开始配置笔记本：![图 12.5 – 创建新实例

![图片 B16722_12_005.jpg]

图 12.5 – 创建新实例
要创建笔记本实例，我们需要选择 Instance name 为 bigqueryml-packt-notebook，Region 为 us-west1，Zone 为 use-west1-a，Operating System 为 Debian 10，以及 Environment 为 Python 3 (with Intel MKL)。
滚动到配置页面，选择 n1-standard-2 作为 机器类型。之后，我们可以通过点击蓝色创建按钮开始创建实例：![图 12.7 – 创建笔记本实例的附加选项

![图片 B16722_12_007.jpg]

图 12.7 – 创建笔记本实例的附加选项
几分钟后，笔记本实例将准备好使用。在选择了 打开 JUPYTERLAB 后，JupyterLab 笔记本将打开一个包含开发环境的新窗口：![图 12.8 – GCP 项目中可用的笔记本实例列表

![图片 B16722_12_008.jpg]

图 12.8 – GCP 项目中可用的笔记本实例列表
在 JupyterLab 笔记本的网页界面中，我们可以通过选择笔记本类型为 Python 3 来初始化第一个笔记本文件：![图 12.9 – 选择笔记本中使用的运行时引擎

![图片 B16722_12_009.jpg]

图 12.9 – 选择笔记本中使用的运行时引擎
在做出此选择后，将创建一个新的笔记本文件，并准备好供我们开发 BigQuery ML 机器学习模型：

![图 12.10 – 当笔记本初始化时，显示一个空文件

![图片 B16722_12_010.jpg]

图 12.10 – 当笔记本初始化时，显示一个空文件

在本节中，我们配置了我们的第一个 AI 平台笔记本。在下一节中，我们将使用它来执行一些代码块，以创建、评估和测试一个 BigQuery ML 机器学习模型。

在笔记本中实现 BigQuery ML 模型

在本节中，我们将利用在 配置第一个笔记本 部分配置的笔记本实例来运行 BigQuery SQL 语句并开发 BigQuery ML 机器学习模型。

要了解如何使用笔记本，我们将重用我们在 第四章 中构建的一些代码块，使用线性回归预测数值。重要的是要记住，用例的目标是预测纽约市自行车共享服务的每次骑行时间。为了实现这一目标，我们训练了一个简单的线性回归机器学习模型。在本节中，我们将使用相同的技巧；也就是说，我们将代码嵌入到 AI 平台笔记本中。

编译 AI 笔记本

在本节中，我们将使用代码单元格嵌入 SQL 查询，并使用Markdown单元格创建标题和描述。让我们通过执行以下步骤开始编译我们的笔记本：

首先，让我们为我们的笔记本创建一个标题。从单元格类型下拉菜单中，我们可以选择Markdown并将以下代码块插入到笔记本的第一个单元格中：
```
# NYC Bike Sharing Linear Regression
```
在以下屏幕截图中，您可以看到第一个单元格的配置方式：

![图 12.11 – Markdown 单元格的示例

图 12.11 – Markdown 单元格的示例

文本前面的#字符用于识别一级标题。
通过在笔记本菜单中点击+按钮，您将添加一个新的单元格。让我们选择Markdown作为单元格类型，并插入以下文本，该文本描述了笔记本：
```
The following steps will show you how to train, evaluate and test a linear regression model using BigQuery ML.
```
为了检查我们是否正确地编写了之前的步骤，我们可以使用笔记本菜单中的运行按钮。我们可以运行每个单元格以可视化结果：![图 12.12 – 笔记本菜单中的运行按钮

图 12.12 – 笔记本菜单中的运行按钮

在以下屏幕截图中，您可以看到执行前两个步骤的结果，其中包含标题和简短描述：

![图 12.13 – 执行前几个单元格的结果

图 12.13 – 执行前几个单元格的结果
让我们在模型的数据准备部分开始之前添加一个副标题。我们将在文本之前添加另一个##字符来识别二级标题。它可以被认为是我们在步骤 1中编写的标题的副标题。
现在，我们准备好创建12_notebook BigQuery 数据集，该数据集将用于托管我们的 BigQuery ML 模型。让我们在当前 GCP 项目中的US下创建一个12_notebook数据集。在单元格末尾，print命令用于显示确认消息，表明数据集已成功创建。

现在，我们可以添加一个新的12_notebook.training_table表格：

%%bigquery
### Creation of the training table ###
CREATE OR REPLACE TABLE `12_notebook.training_table` AS
              SELECT 
                    tripduration/60 tripduration,
                    starttime,
                    stoptime,
                    start_station_id,
                    start_station_name,
                    start_station_latitude,
                    start_station_longitude,
                    end_station_id,
                    end_station_name,
                    end_station_latitude,
                    end_station_longitude,
                    bikeid,
                    usertype,
                    birth_year,
                    gender,
                    customer_plan
              FROM
                    `bigquery-public-data.new_york_citibike.citibike_trips`
              WHERE 
                    (
                        (EXTRACT (YEAR FROM starttime)=2017 AND
                          (EXTRACT (MONTH FROM starttime)>=04 OR EXTRACT (MONTH FROM starttime)<=10))
                        OR (EXTRACT (YEAR FROM starttime)=2018 AND
                          (EXTRACT (MONTH FROM starttime)>=01 OR EXTRACT (MONTH FROM starttime)<=02))
                    )
                    AND (tripduration>=3*60 AND tripduration<=3*60*60)
                    AND  birth_year is not NULL
                    AND birth_year < 2007;

%%bigquery关键字允许我们包含包含 SQL 查询的代码块。SQL 语句将通过 AI 平台笔记本和关系型数据库的本地集成直接在 BigQuery 上运行。

创建表格的业务逻辑与我们用于在第四章中创建04_nyc_bike_sharing.training_table表格的方式相同，使用线性回归预测数值。

现在，让我们在第四章中包含一个额外的04_nyc_bike_sharing.evaluation_table表格，使用线性回归预测数值。
最后，让我们在第四章中添加另一个04_nyc_bike_sharing.prediction_table表格，使用线性回归预测数值。
让我们在模型的训练部分开始之前添加一个副标题。我们将通过插入以下标题来添加一个Markdown单元格：
```
## Training the linear regression
```
现在，我们已经准备好编写将使用笔记本训练我们的机器学习模型的 BigQuery ML 查询。让我们添加一个新的`12_notebook.trip_duration_notebook`机器学习模型，它包含我们在第四章中使用的相同业务逻辑，即使用`04_nyc_bike_sharing.trip_duration_by_stations_and_day`模型来训练。
让我们在模型的训练部分开始之前添加一个副标题。我们将通过插入以下标题来添加一个Markdown单元格：
```
## Evaluating the linear regression
```
现在，我们已经准备好编写将评估机器学习模型的 BigQuery ML 查询。让我们添加一个新的`12_notebook.trip_duration_notebook`机器学习模型，它包含我们在第四章中使用的相同业务逻辑，即使用`04_nyc_bike_sharing.trip_duration_by_stations_and_day`模型来评估。
让我们在模型的预测部分开始之前添加一个副标题。我们将通过插入以下标题来添加一个Markdown单元格：
```
## Testing the linear regression
```
现在，我们可以包含我们将用于我们的机器学习模型的 BigQuery ML 查询。让我们添加一个新的`12_notebook.trip_duration_notebook`机器学习模型，它包含我们在第四章中使用的相同业务逻辑，即使用`04_nyc_bike_sharing.trip_duration_by_stations_and_day`模型来预测数值。
在编译阶段结束时，我们可以使用主菜单中的保存笔记本按钮或使用另存为笔记本…选项来保存笔记本。

在本节中，我们使用代码单元格和 Markdown 单元格编译了我们的笔记本。在下一节中，我们将运行笔记本中编写的代码。

在 AI 笔记本中运行代码

在本节中，我们将运行我们在编译 AI 笔记本部分编写的代码。让我们先看看我们准备好的笔记本。

在下面的屏幕截图中，我们可以可视化我们的 AI 笔记本，它交替显示描述性单元格和代码单元格：

![Figure 12.14 – The entire notebook file compiled

![img/B16722_12_014.jpg]

图 12.14 – 整个笔记本文件已编译

要运行整个笔记本，我们只需在窗口顶部打开运行菜单并选择运行所有单元格，如图所示：

![Figure 12.15 – Running all the cells

![img/B16722_12_015.jpg]

图 12.15 – 运行所有单元格

选择运行所有单元格后，AI 平台笔记本中的所有单元格将依次执行。

在评估步骤结束时，ML.EVALUATE函数的结果将在评估线性回归部分显示。

以下截图显示了评估阶段返回的值：

![Figure 12.16 – 评估函数返回的值

图 12.16 – 评估函数返回的值

在预测步骤结束时，ML.PREDICT函数的结果将在“测试线性回归”部分显示。

在以下截图中，我们可以可视化笔记本末尾呈现的结果：

![Figure 12.17 – PREDICT 函数返回的值

图 12.17 – PREDICT 函数返回的值

如您所见，在执行代码块后，笔记本立即在 SQL 语句之后呈现预测结果。如果我们希望提高 BigQuery ML 开发步骤的可读性和理解性，这一特性尤为重要。

在本节中，我们学习了如何编译人工智能笔记本以及如何运行包含代码块或标题和描述的所有单元格。

摘要

在本章中，我们学习了人工智能笔记本是什么以及为什么它们在机器学习模型开发中可能很有用，我们还了解了定价模型。我们发现了 Google AI Platform Notebooks 与开源环境 JupyterLab 之间的关系。

首先，我们使用 Google Cloud Console 网页界面配置了我们的第一个笔记本实例。然后，我们使用这个新实例开发了一个简单的线性回归模型，同时在笔记本文件中交替使用代码块和描述性单元格。

最后，我们在笔记本中执行了所有步骤，并在其网页界面中直接可视化结果。

在下一章中，我们将学习如何使用 BigQuery ML 直接从 BigQuery 调用 TensorFlow 模型。

第十三章：使用 BigQuery ML 运行 TensorFlow 模型

TensorFlow 是最常用且相关的机器学习（ML）框架之一。它允许数据科学家和机器学习工程师开发高级模型，同时也提供了极大的灵活性和丰富的数学函数集。

TensorFlow 提供的先进功能为想要利用数据科学家和机器学习工程师开发的现有模型的数据分析师提供了巨大的机会。

此外，BigQuery ML 与 TensorFlow 之间的互操作性代表了填补公司内部业务和技术利益相关者之间差距的一种方式。第一组通常更关注数据的深入知识，而第二组则更侧重于技术导向和编程技能。

在本章中，我们将学习 TensorFlow 是什么以及如何与 BigQuery ML 一起使用。我们将了解如何将 BigQuery ML 模型导出为 TensorFlow 格式，以及如何使用 BigQuery ML SQL 语法运行 TensorFlow 模型。

为了了解我们如何将 BigQuery ML 与 TensorFlow 相结合，我们将涵盖以下主题：

介绍 TensorFlow
探索 BigQuery ML 与 TensorFlow 之间的关系
将 BigQuery ML 模型转换为 TensorFlow
使用 BigQuery ML 运行 TensorFlow 模型

技术要求

本章要求您能够访问网络浏览器并利用以下资源：

一个 GCP 账户来访问 Google Cloud 控制台
一个 GCP 项目来托管 BigQuery 数据集
一个 GCP 项目来托管 Google Cloud 存储桶

现在我们已经涵盖了技术要求，让我们开始探索 BigQuery ML 用于 TensorFlow 模型。

查看以下视频以查看代码的实际应用：bit.ly/33ngmdf

介绍 TensorFlow

在本节中，我们将介绍TensorFlow，其起源以及这个框架在机器学习（ML）社区中所取得的成就。

TensorFlow是一个开源库，用于开发机器学习（ML）模型。它非常灵活，可以用于解决各种用例和业务场景。由于 TensorFlow 基于数学函数，其名称来源于数学概念张量。

在数学中，张量是一个代数对象，它描述了其他代数对象集合之间的关系。张量的例子包括矢量和矩阵。

TensorFlow 库最初是由谷歌工程师创建的，并于 2015 年以 Apache 许可证发布。现在，由于其潜力和灵活性，它被认为是最受欢迎的机器学习（ML）框架之一。实际上，TensorFlow 模型可以在本地机器、本地服务器、云中或边缘设备上执行，例如在手机和视频监控摄像头中。

重要提示

边缘计算是一种将业务逻辑的计算更靠近所需位置的计算范式。当 ML 模型在边缘运行时，它通常直接在收集模型所需数据的传感器或摄像头上执行，而无需连接到其他系统。

TensorFlow 在 ML 社区中得到广泛应用，并应用于解决人工智能领域中的不同挑战，例如以下内容：

Airbnb 利用 TensorFlow 对客户照片进行分类，从而改善了出租房屋的虚拟游览。更多详情，请访问以下链接：medium.com/airbnb-engineering/categorizing-listing-photos-at-airbnb-f9483f3ab7e3。
Google 使用 TensorFlow 为其产品赋予人工智能能力，例如 Google 搜索、Gmail 和 Translate。更多详情，请访问以下链接：ai.googleblog.com/search/label/TensorFlow。
PayPal 使用 TensorFlow 来防止欺诈，并将 ML 应用于提高其欺诈检测模型的准确性。更多详情，请访问以下链接：medium.com/paypal-engineering。
Twitter 利用 TensorFlow 识别并向用户展示最相关的推文。更多详情，请访问以下链接：blog.tensorflow.org/2019/03/ranking-tweets-with-tensorflow.html。
其他有趣的用例可以在 TensorFlow 案例研究网页上找到，网址为 www.tensorflow.org/about/case-studies?hl=en。

与 BigQuery ML 相比，使用 TensorFlow 开发 ML 模型需要高级编程技能。实际上，TensorFlow 库的高度灵活性是通过在代码开发上投入一定时间来创建模型的需求来平衡的。现在，建议使用 Python 来开发 TensorFlow 的 ML 模型。

一旦 TensorFlow 模型的开发和训练阶段完成，就可以将其导出为 SavedModel 格式。

SavedModel 格式包含整个 TensorFlow 模型。此格式允许我们在所有兼容环境中无需再次运行代码即可部署模型。SavedModel 由多个文件和文件夹组成，这些文件和文件夹存储在同一个父文件夹中：

SavedModel 文件存储 TensorFlow 逻辑。此文件称为 saved_model.pb。
variables 目录包含训练模型的参数。
assets 文件夹可以包含 ML 模型使用的外部和附加文件。

当 TensorFlow 模型处于 SavedModel 格式时，它可以在我们希望使用此模型的平台轻松加载和使用。该平台可以是物理服务器、云实例、智能手机或 物联网（IoT）设备。

在本节中，我们介绍了 TensorFlow 的基础知识。在下一节中，我们将探讨 BigQuery ML 如何与 TensorFlow 相关联。

探索 BigQuery ML 和 TensorFlow 之间的关系

在本节中，我们将了解 BigQuery ML 和 TensorFlow 之间的关系。完成本节后，我们将能够根据我们的用例理解何时使用 BigQuery ML 和 TensorFlow，以及如何在使用这两种技术时获得最佳效果。

理解共性和差异

BigQuery ML 和 TensorFlow 有一些相似之处，但也有一些相关的差异需要强调。

在以下表格中，我们总结了这两个框架的主要相似点和差异点：

![图 13.1 – 比较 BigQuery ML 和 TensorFlow

![img/B16722_13_001.jpg]

图 13.1 – 比较 BigQuery ML 和 TensorFlow

首先，重要的是要强调 TensorFlow 在实现 ML 模型方面提供了更大的灵活性。虽然 BigQuery ML 以其支持的特定模型类型列表（https://cloud.google.com/bigquery-ml/docs/introduction#supported_models_in）为特征，但 TensorFlow 提供了更广泛的 ML 技术范围。

BigQuery ML 被设计为 BigQuery 的扩展，因此它只关注结构化数据，这些数据可以用表格格式表示。所有 BigQuery ML 技术都是基于在 BigQuery 表中存储的行上训练和应用模型的可能性。另一方面，TensorFlow 对不同的格式开放，包括自由文本、图像、音频和视频。

要训练、评估和测试 BigQuery ML 模型，用户应了解 SQL 语法并具备基本的 ML 经验。另一方面，实现 TensorFlow 模型则需要良好的编程技能和对 ML 主题的良好了解，因为该框架在定制方面提供了更高的灵活性。

考虑到这两种技术的特点，很明显，它们针对的是公司中的不同利益相关者。虽然 BigQuery ML 可以轻松被熟悉数据分析任务和 SQL 查询的业务分析师和数据分析师使用，但 TensorFlow 是为高级程序员设计的，例如经验丰富的数据科学家和 ML 工程师。

现在我们已经理解了 BigQuery ML 和 TensorFlow 的共性和差异，在下一节中，我们将学习这两个框架如何相互补充。

与 BigQuery ML 和 TensorFlow 协作

在本节中，我们将探讨如何结合使用 BigQuery ML 和 TensorFlow，以充分利用这两种技术。

以下图表显示了使用 BigQuery ML 和 TensorFlow 的业务分析师和数据科学家之间的交互：

![图 13.2 – BigQuery ML 和 TensorFlow 之间的交互

![img/B16722_13_002.jpg]

图 13.2 – BigQuery ML 和 TensorFlow 之间的交互

如我们在第一章中所述，“Google Cloud 和 BigQuery 简介”，ML 开发周期的第一步是探索数据并完全理解它。

在分析的第一阶段之后，需要对数据进行清理和准备，以便训练 ML 算法。这一阶段对于创建有价值的 ML 模型并进入训练阶段至关重要。

当真正开发 ML 模型时，根据我们的知识、背景和以往经验，我们有两种选择：

如果你是一名业务分析师或数据分析师，你将更喜欢使用 BigQuery ML，因为它简单直观，得益于 SQL 语法。
如果你是一名数据科学家或 ML 工程师，你将选择训练一个 TensorFlow 模型，因为它具有灵活性，并且提供了更多定制的机会。

如前图所示，上部分代表利用 BigQuery ML SQL 语句在已存储在 BigQuery 中的数据上创建、评估和使用 ML 模型的业务分析师或数据分析师的典型工作流程。这一部分要求你具备良好的 SQL 语言知识、ML 基础知识以及底层数据。

另一方面，图的下部分代表基于由数据科学家或 ML 工程师创建的 TensorFlow 库的开发过程，这些人在编程和 ML 算法方面拥有丰富的经验。

通常，数据分析师对数据非常了解，但对最先进的编程技术知之甚少，而数据科学家和 ML 工程师具有深入的编码技能，但对业务数据的理解有限。这种情况通常发生在更成熟的公司中，因为员工具有不同的专业背景。这种情况通常会导致那些对行业非常了解的人和那些更专注于编程的业务流程之间产生摩擦。

为了减少这种差距并减轻摩擦的风险，BigQuery ML 允许我们做以下事情：

将使用 BigQuery ML 开发的 ML 模型导出为 TensorFlow SavedModel 格式。
导入以 SavedModel 格式保存的 TensorFlow ML 模型。

观察前图，我们可以看到业务分析师可以将 BigQuery ML 模型导出并部署到与 BigQuery 不同但兼容 TensorFlow 的其他环境中。

另一方面，已经实现了高级 TensorFlow 模型的数据科学家可以将它们保存到 Google Cloud 存储桶中，这意味着它们可以被导入到 BigQuery ML 中。

这种 BigQuery ML 和 TensorFlow 框架之间的双向交互使我们能够做以下事情：

扩展 BigQuery ML 模型的适用性，使其不再局限于使用存储在 BigQuery 中的数据。
导入 BigQuery ML 高级 TensorFlow 模型，这些模型最初不支持 BigQuery ML 语法，并通过 SQL 查询在 BigQuery 中使用它们。

在本节中，我们学习了 BigQuery ML 和 TensorFlow 如何交互，以及为什么利用这种集成如此重要。在下一节中，我们将训练一个 BigQuery ML 模型并将其导出为 TensorFlow 格式。

将 BigQuery ML 模型转换为 TensorFlow

在本节中，我们将训练与我们在 第十一章 的 实现深度神经网络 部分中训练的相同深度神经网络，然后将其导出为 TensorFlow SavedModel 格式。

训练 BigQuery ML 以导出它

在我们开始训练模型之前，让我们访问 BigQuery 来创建用于训练和预测的数据集和表格：

登录我们的 Google Cloud Console，并通过导航菜单访问 BigQuery 用户界面。
在我们为 第二章 的 设置您的 GCP 和 BigQuery 环境 创建的项目下创建一个新的数据集。对于此用例，我们将创建一个名为 13_tensorflow_model 的数据集，并使用默认选项。

现在，我们已经准备好创建一个包含训练数据集的表格。让我们执行以下 SQL 语句：

CREATE OR REPLACE TABLE `13_tensorflow_model.training_table` AS
              SELECT
                   tripduration/60 tripduration,
                   start_station_name,
                   end_station_name,
                   IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR EXTRACT(DAYOFWEEK FROM starttime)=7, true, false) is_weekend,
                   EXTRACT(YEAR FROM starttime)-birth_year as age
              FROM
                    `bigquery-public-data.new_york_citibike.citibike_trips`
              WHERE
                    (
                        (EXTRACT (YEAR FROM starttime)=2017 AND
                          (EXTRACT (MONTH FROM starttime)>=04 OR EXTRACT (MONTH FROM starttime)<=10))
                        OR (EXTRACT (YEAR FROM starttime)=2018 AND
                          (EXTRACT (MONTH FROM starttime)>=01 OR EXTRACT (MONTH FROM starttime)<=02))
                    )
                    AND (tripduration>=3*60 AND tripduration<=3*60*60)
                    AND  birth_year is not NULL
                    AND birth_year < 2007;

此查询的结果存储在新的 `13_tensorflow_model.training_table` 表中，我们创建此表是为了支持我们用例的以下步骤。

此查询的业务逻辑与我们在 第十一章 的 准备数据集 部分中应用的逻辑相同。

现在，我们将创建一个用于测试我们的 ML 模型的表格：

CREATE OR REPLACE TABLE  `13_tensorflow_model.prediction_table` AS
              SELECT
                   tripduration/60 tripduration,
                   start_station_name,
                   end_station_name,
                   IF (EXTRACT(DAYOFWEEK FROM starttime)=1 OR EXTRACT(DAYOFWEEK FROM starttime)=7, true, false) is_weekend,
                   EXTRACT(YEAR FROM starttime)-birth_year as age
                        FROM
                    `bigquery-public-data.new_york_citibike.citibike_trips`
              WHERE
                    EXTRACT (YEAR FROM starttime)=2018
                    AND EXTRACT (MONTH FROM starttime)=05
                     AND (tripduration>=3*60 AND tripduration<=3*60*60)
                    AND  birth_year is not NULL
                    AND birth_year < 2007;

此查询应用了用于创建训练表的相同逻辑，但只考虑了 2018 年 5 月。

现在，让我们训练我们的 ML 模型，该模型将在 导出 BigQuery ML 模型 部分中导出为 TensorFlow 格式：
```
CREATE OR REPLACE MODEL `13_tensorflow_model.bigquery_ml_model_to_export`
OPTIONS
  (model_type='DNN_REGRESSOR',
        ACTIVATION_FN = 'CRELU') AS
SELECT
  start_station_name,
  end_station_name,
  is_weekend,
  age,
  tripduration as label
FROM
  `13_tensorflow_model.training_table`;
```
创建 `13_tensorflow_model.bigquery_ml_model_to_export` ML 模型所使用的业务逻辑与我们在 第十一章 的 训练深度神经网络模型 部分中使用的逻辑相同，实现深度神经网络。

现在我们已经训练了一个 ML 模型，在下一节中，我们将学习如何将其导出为 TensorFlow SavedModel 格式。

导出 BigQuery ML 模型

在本节中，我们将导出一个 BigQuery ML 模型到 Google Cloud 存储桶中的 TensorFlow SavedModel 格式。让我们开始吧：

首先，我们需要从 Google Cloud Console 访问 Cloud Shell：![图 13.3 – Google Cloud Console 中的激活 Cloud Shell 按钮

![img/B16722_13_003.jpg]

图 13.3 – Google Cloud Console 中的激活 Cloud Shell 按钮

重要提示

云壳是一个基于 Linux 的在线环境，可以通过 Google Cloud 控制台的网页浏览器访问。使用云壳，您可以通过利用其预加载的实用程序（如 gcloud 命令行工具）来管理您的 Google Cloud 资源。
点击云壳按钮后，将在屏幕底部提供 Linux 命令行。如果您是第一次使用 Google Cloud Shell，将显示以下横幅：

图 13.4 – 云壳信息框

点击蓝色继续按钮后，将提供 Linux 命令行，如下截图所示：

图 13.5 – 云壳环境
我们需要通过运行以下命令对 Google Cloud SDK 的账户进行认证：
```
gcloud auth login
```
命令行将显示一个网页 URL。通过点击此 URL，我们将授权账户使用 Cloud SDK。在此过程结束时，您将在网页上看到一个代码，您可以将其复制并粘贴到 Cloud Shell 中以完成授权过程。
然后，我们可以运行以下命令来设置新的 PROJECT 变量中的当前项目名称：
```
PROJECT=$(gcloud config get-value project)
```
使用 PROJECT 变量，我们将创建第二个变量 BUCKET，它将包含要创建的 Google Cloud 存储桶的名称，BigQuery ML 模型将导出到该存储桶：
```
BUCKET=${PROJECT}-us-bigqueryml-export-tf
```
Google Cloud 存储桶的名称将是我们的项目名称和 -us-bigqueryml-export-tf 字符串的连接。
现在我们已经将存储桶的名称存储在一个变量中，我们可以通过运行以下命令来创建新的存储桶：
```
gsutil mb -l us gs://${BUCKET}
```
重要提示

使用 gsutil mb 命令创建新的存储桶，而 –l US 选项指定了我们希望创建存储桶的地理位置。在这种情况下，存储桶将在美国创建。

如果您是第一次使用 Cloud Shell 创建 Google Cloud 存储桶，则在创建存储桶之前将出现以下横幅：

图 13.6 – 云壳授权框

点击蓝色授权按钮后，将创建存储桶。
现在，让我们执行以下命令，将 BigQuery ML 模型以 TensorFlow SavedModel 格式导出到 Google Cloud 存储桶中。让我们运行以下命令：
```
     bq extract -m 13_tensorflow_model.bigquery_ml_model_to_export gs://${BUCKET}/bqml_exported_model
```
使用 bq extract 命令提取 –m 选项后面的指定 BigQuery ML 模型。命令的最后部分表示我们想要提取模型及其相关子文件夹的 Google Cloud 存储桶路径；即 bqml_exported_model。作为替代，也可以使用以下 SQL 查询来导出 BigQuery ML 模型：
```
EXPORT MODEL 13_tensorflow_model.bigquery_ml_model_to_export
OPTIONS (URI = "gs://${BUCKET}/bqml_exported_model" );
```
要验证导出模型的存档，我们可以浏览 Google Cloud 控制台菜单，并在存储下访问浏览器功能，如下面的截图所示：![图 13.7 – Google Cloud Storage – 浏览器]

![img/B16722_13_007.jpg]

图 13.7 – Google Cloud Storage – 浏览器

在访问我们在步骤 6中创建的 Google Cloud 存储桶并进入bqml_exported_model子文件夹后，我们将看到 BigQuery ML 模型的导出版本，如下面的截图所示：

![图 13.8 – 导入到 TensorFlow SavedModel 格式的 BigQuery ML 模型]

![img/B16722_13_008.jpg]

图 13.8 – 导入到 TensorFlow SavedModel 格式的 BigQuery ML 模型

从这个文件列表中，我们可以轻松识别出我们在本章介绍 TensorFlow部分中提到的 TensorFlow SavedModel 格式的主体组件。我们可以看到包含 TensorFlow 程序的saved_model.pb文件，以及assets和variables文件夹和一些额外的元数据文件。

现在模型已经导出到 TensorFlow SavedModel 格式，可以与他人共享，并在 BigQuery 之外的 TensorFlow 兼容环境中运行。

在本节中，我们学习了如何使用 TensorFlow SavedModel 格式将 BigQuery ML 模型导出到 Google Cloud 存储桶。在下一节中，我们将学习如何将现有的 TensorFlow 模型导入到 BigQuery ML 中。

使用 BigQuery ML 运行 TensorFlow 模型

在本节中，我们将导入在将 BigQuery ML 模型转换为 TensorFlow部分中导出的 TensorFlow 模型。一旦模型被导入，我们将通过 BigQuery ML 语法使用它。

首先，我们需要记住我们的 BigQuery ML 模型已经被导出到 Google Cloud 存储桶的文件夹中。该 ML 模型以 TensorFlow SavedModel 格式存储，并且与任何其他由使用 TensorFlow 的数据科学家开发的 ML 模型具有相同的格式。

如果我们想在 BigQuery ML 中使用 TensorFlow 模型，我们需要执行以下步骤：

首先，让我们运行CREATE OR REPLACE MODEL SQL 语句。请注意，存储桶的路径'gs://<PROJECT_NAME>-us-bigqueryml-export-tf/bqml_exported_model/*'是基于您当前项目的名称，因此您需要将<PROJECT_NAME>占位符替换为您正在工作的项目名称：
```
CREATE OR REPLACE MODEL `13_tensorflow_model.trip_duration_tf_imported_model`
OPTIONS (model_type='tensorflow',
         model_path='gs://<PROJECT_NAME>-us-bigqueryml-export-tf/bqml_exported_model/*');
```
查询的语法由CREATE OR REPLACE MODEL关键字组成，后跟新 ML 模型的标识符；即13_tensorflow_model.trip_duration_tf_imported_model。

在OPTIONS子句中，我们在model_type选项中指定了'tensorflow'。使用model_path参数，我们指定了 TensorFlow SavedModel 将在 Google Cloud 存储桶中存储的文件夹。
为了验证 BigQuery ML 成功加载了 TensorFlow 模型，我们可以浏览 BigQuery 导航菜单，并检查模型是否存在于 13_tensorflow_model 数据集中。

以下截图显示了 TensorFlow 模型已经被导入到 BigQuery ML 中。其名称为 trip_duration_tf_imported_model：

图 13.9 – 导入到 BigQuery 的 TensorFlow 模型
如果我们点击 trip_duration_tf_imported_model，我们将能够访问机器学习模型的详情。

以下截图显示了导入的机器学习模型的详情：

图 13.10 – 我们导入到 BigQuery 的机器学习模型的详情

在模型的详情页面上，我们可以清楚地看到模型类型是 TENSORFLOW。这一特性确认了，原始的机器学习模型原本是以 TensorFlow SavedModel 格式存在的，并且已经被导入到 BigQuery ML 中。

现在，我们可以使用导入的 TensorFlow 模型与 BigQuery ML 的 ML.PREDICT 函数。让我们运行以下 SQL 语句：

SELECT
  *
FROM
  ML.PREDICT(MODEL `13_tensorflow_model.trip_duration_tf_imported_model`,
    (
    SELECT
         start_station_name,
          end_station_name,
          is_weekend,
          age,
          tripduration
    FROM
           `13_tensorflow_model.prediction_table`));

查询的结果将在几秒钟后在 BigQuery UI 中展示。

以下截图显示了查询的执行结果，以及由机器学习模型生成的预测：

图 13.11 – 由导入到 BigQuery 的 TensorFlow 模型生成的预测

如我们所见，预测值存储在 predictions 列中，并代表使用自行车共享服务从 start_station_name 到 end_station_name 的预测行程时间。

在本节中，我们学习了如何将 TensorFlow 模型导入到 BigQuery ML 中，以及如何通过利用 BigQuery ML SQL 语法来使用它。

摘要

在本章中，我们学习了 TensorFlow 是什么以及为什么它在机器学习行业中如此重要。

首先，我们分析了 BigQuery ML 和 TensorFlow 之间的主要共同点和差异，并了解到它们针对的是机器学习社区中的不同目标受众。

然后，我们发现了如何通过结合这两个框架来补充 BigQuery ML 和 TensorFlow，以获得最大价值。

通过采取逐步渐进的方法，我们学习了如何将 BigQuery ML 模型导出为 TensorFlow 格式，以便我们可以在除了 BigQuery 以外的环境中部署它们。

之后，我们测试了如何在 BigQuery ML 中导入和使用 TensorFlow 模型。这种方法使得数据分析师可以轻松访问和使用由数据科学家和机器学习工程师开发的先进 TensorFlow ML 模型。最后，在导入机器学习模型后，我们在 BigQuery 表上测试了导入的机器学习模型，以预测使用纽约市自行车共享服务的骑行行程时间。

在下一章中，我们将关注一些 BigQuery 技巧和最佳实践，以便我们进一步提高我们的机器学习技能。

进一步资源

纽约市自行车共享公共数据集: console.cloud.google.com/marketplace/product/city-of-new-york/nyc-citi-bike
为 TensorFlow 创建 BigQuery ML 模型: https://cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-tensorflow
评估 BigQuery ML 模型: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-evaluate
BigQuery ML 预测: cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-predict
TensorFlow 官方网站: https://www.tensorflow.org/

第十四章：BigQuery ML 技巧和最佳实践

BigQuery ML 具有民主化数据分析师和业务分析师使用 机器学习（ML）的优势。实际上，BigQuery ML 允许没有任何编程经验的用户实施高级 ML 算法。尽管 BigQuery ML 设计用于简化并自动化 ML 模型的创建，但在 ML 算法的开发生命周期中，仍有一些最佳实践和技巧应该被采用，以获得有效的性能。

拥有数据科学背景可以帮助我们在进一步提高 ML 模型的性能以及避免在用例实施过程中的陷阱。在本章中，我们将学习如何为每个特定的业务场景选择正确的技术，并了解我们可以利用的工具来提高 ML 模型的性能。

按照典型的 ML 开发生命周期，我们将讨论以下主题：

选择合适的 BigQuery ML 算法
准备数据集
理解特征工程
调整超参数
使用 BigQuery ML 进行在线预测

选择合适的 BigQuery ML 算法

在本节中，我们将学习在实施 ML 模型之前定义一个明确的企业目标为什么如此重要，并了解哪些 BigQuery ML 算法适用于每个特定的用例。

重要提示

数据科学家是负责收集、分析和理解大量数据的专业人士。这个角色通常需要统计和编码技能的混合。

数据分析师与数据科学家不同。数据分析师更专注于行业知识和业务流程，而不是编码和编程技能。这个角色的人拥有大量数据操作和可视化的经验，能够从数据中提出相关的业务洞察。

为了在机器学习（ML）中获得有意义的成果，有必要定义一个明确的企业目标。在开始实际实施 ML 模型之前，数据分析师和数据科学家应该清楚地定义他们希望实现的企业目标。

一种设置明确目标最著名的技巧被称为 具体、可衡量、可实现、相关和基于时间（SMART）框架。在这个范式下，每个字母代表我们的最终目标应该满足的特定特征，如下所述：

具体性：有必要定义一个明确且精确的企业目标。
可衡量性：为了理解 BigQuery ML 模型是否满足我们的标准，我们需要选择一个或多个 关键绩效指标（KPI），例如 接收者操作特征（ROC），曲线下面积（AUC）值，或 平均绝对误差（MAE）。
可达成：我们需要分析我们想要解决的用例的复杂性，并设定合理的期望——例如，我们不能期望我们的 BigQuery ML 模型 100%地预测正确的值。
相关：我们需要将精力集中在最重要的用例上，因为可能某些业务场景只能为我们公司带来有限的优势。
基于时间：作为数据分析师和数据科学家，我们在时间方面资源有限。集中精力在正确的目标上对于为公司创造价值是至关重要的。

我们可以将 SMART 框架应用于 ML 领域，以帮助我们选择正确的用例和正确的 BigQuery ML 算法来使用。

例如，在下面的表中，您可以可视化 SMART 框架应用于我们在第四章，使用线性回归预测数值中开发的用例：

图 14.1 – 将 SMART 框架应用于 ML 用例

一旦我们使用 SMART 方法定义了我们的业务目标，我们就准备好选择最佳的 BigQuery ML 算法，以帮助我们解决业务场景。

根据我们想要实现的企业目标和我们可以利用的训练数据集，我们可以确定可以解决我们用例的 BigQuery ML 算法。

在下面的表中，我们可以看到我们可以用于开发我们的 ML 模型的所有 BigQuery ML 技术的总结：

图 14.2 – 一瞥 BigQuery ML 算法

为了实现我们的目标，我们可以导航到图 14.2中表示的表，并清楚地找到可以解决我们用例的 BigQuery ML 算法。例如，对于我们在图 14.1中分析的业务场景，我们可以断言以下内容：

我们在第四章，使用线性回归预测数值中使用的 BigQuery 公共数据集是一个标记数据集，因为对于每条记录，它包括过去行程的行程时间。
预期的结果是连续的实数。实际上，用例的目标是预测行程时间，以分钟为单位。

通过查看图 14.2中提供的表格，我们注意到我们可以使用以下 BigQuery ML 算法之一来解决我们的预测用例：

线性回归
提升树 – XGBoost – 回归
深度神经网络 – 回归

在本节中，我们学习了如何设定明确的企业目标。然后，我们了解了我们可以使用哪些 BigQuery ML 技术来解决我们的业务目标。在下一节中，我们将专注于准备数据集以获得有效的 ML 模型。

准备数据集

在本节中，我们将学习哪些技术可以应用以确保我们用于构建机器学习模型的数据是正确的并产生预期的结果。之后，我们将探讨我们可以使用的策略来将数据集分割为训练集、验证集和测试集。

与高质量数据一起工作

在本节中，我们将了解我们的数据集应该具备哪些特征，以便开发有效的 BigQuery ML 模型。

由于机器学习模型是从数据中学习的，因此向我们的机器学习算法提供高质量的数据非常重要，尤其是在训练阶段。由于数据质量是一个非常广泛的话题，需要一本书来详细分析它。因此，我们将仅关注与构建机器学习模型相关的主要数据质量概念。

重要提示

数据质量是一个包括过程、专业人员、技术和最佳实践的学科，用于识别和纠正数据中的异常、错误和缺陷。

这种做法对于支持基于可信和负担得起的数据洞察的商业决策至关重要。

我们可以根据不同的数据质量维度来衡量数据集的质量。

在下面的图中，你可以看到用于衡量数据质量的不同维度：

![图 14.3 – 数据质量维度]

![图片 B16722_14_003.jpg]

图 14.3 – 数据质量维度

我们可以根据以下维度来评估数据集的质量：准确性、完整性、一致性、及时性、有效性和唯一性。

在接下来的章节中，我们将解释每个数据质量维度以及为什么它对于机器学习模型的实现很重要。

准确性

准确性指的是我们数据集中可用的信息。如果一个数值是错误的并且不反映现实，这将影响建立在它之上的 BigQuery ML 模型的有效性。

发现不准确的信息并不容易，但我们可以应用一些数据质量检查来识别数据中的相关问题——例如，我们可以执行查询来识别并最终删除包含错误值的记录。

在下面的表格中，你可以看到一个典型的不准确数据示例，其中包含一个负值来表示一个人的年龄：

![图 14.4 – 一个年龄列中存在不准确值的表格示例]

![图片 B16722_14_004.jpg]

图 14.4 – 一个年龄列中存在不准确值的表格示例

在SELECT查询中使用MAX和MIN运算符可以是一个很好的方法来找到列中的错误值。这些记录被称为异常值，因为它们与其他列中的记录相比具有非常不同的值。执行一些初步的结构化查询语言（SQL）查询以提取特征和标签的最大值和最小值对于帮助识别数据集中最相关的错误非常有用。

例如，在图 14.4中，Alice 的年龄将在年龄列中被识别为异常值。在这些情况下，我们可以考虑过滤掉具有非现实值的记录。

完整性

NULL字段，这些字段将影响我们模型的表现。

在以下表中，你可以看到一个不完整数据的示例：

![图 14.5 – 年龄列中存在不完整值的表格示例

图 14.5 – 年龄列中存在不完整值的表格示例

为了防止存在不完整记录，最有效的解决方案是在查询中应用特定的过滤器，以排除具有缺失值的记录。一个典型的完整性检查是在特征或模型的标签不应为空且应不同于NULL时添加WHERE子句。

在以下代码片段中，你可以看到一个应用了完整性检查的SELECT语句示例，针对<TEXT_FIELD>占位符：

SELECT *
FROM <TABLE_NAME>
WHERE
    <TEXT_FIELD> IS NOT NULL AND <TEXT_FIELD> <> ''

在前面的示例中，我们正在对由<TABLE_NAME>占位符表示的表应用完整性检查。质量检查验证<TEXT_FIELD>字段不等于NULL且不为空。

如果一条记录包含不完整的字段，我们可以选择从数据集中排除此记录，或者用默认值替换缺失值以填补空白。

一致性

在数据中实现一致性是执行的最复杂任务之一。在企业环境中，相同的数据通常存储在多个位置，可能以不同的格式或单位表示。当一个列的值与其他列的值不兼容时，数据是不一致的。

例如，我们可以想象一个包含以°C 表示的温度的列和另一个以°F 表示相同温度的列的表。如果这两个值应该代表相同的温度但计算不准确，则表将显示不一致性。

在以下表中，你可以看到第二条记录在温度值上存在不一致性：

![图 14.6 – 温度列中存在不一致值的表格示例

图 14.6 – 温度列中存在不一致值的表格示例

在图 14.6中，第二条记录——对应于在巴黎测量的温度——在°C 和°F 尺度之间存在不一致性。

为了检查数据的一致性，我们通常应该在同一个表或不同表中的多个字段上应用验证检查。

及时性

及时性在需要使用 BigQuery ML 模型时尤为重要。当我们训练 ML 模型时，我们需要确保在 ML 模型执行时，训练阶段使用的所有特征都将可用。

在第四章（Chapter 4）的商业场景中，使用线性回归预测数值，我们使用了自行车租赁公司的起始站和终点站来预测行程时长。在这种情况下，我们利用起始站和终点站训练了 BigQuery ML 模型，但如果在预测时终点站不可用，ML 模型就变得不适用且毫无价值。

为了避免这种常见的错误，我们需要检查所有用于训练模型的特征在预测阶段（当 ML 模型生成预测时）也将可用。

有效性

值的有效性严格相关于字段应有的预期格式。如果一个列包含以DD/MM/YYYY格式表示的日期值，而其中一个记录呈现的格式为DD-MM-YYYY，则该记录的有效性会受到损害。

在以下表中，您将注意到第二个记录对于出生日期字段呈现了一个无效值：

图 14.7 – 一个在出生日期列中包含无效值的表的示例

为了满足这一维度，我们必须检查一个列中所有值都存储在相同的格式和同一种方式中。为了检查每个字段的精确格式，我们可以将正则表达式应用于列中的值。

唯一性

唯一信息意味着在一个表中恰好有一个记录来表示一个特定的项目。数据重复可能由几个原因造成，例如数据摄取过程中的错误，或在数据加载过程中的不可控中断和重启。

为了防止这些错误，我们需要知道构成我们记录的主键（PK）的字段，并且我们需要检查PK与一个——并且只有一个——记录匹配。

重要提示

在一个表中，PK是唯一标识一行的最小列集。

重复记录的存在可能导致 ML 模型从非实际但由技术错误生成的发生中学习。

现在我们已经发现了在实施我们的 BigQuery ML 模型之前需要检查的所有数据质量维度，让我们来看看我们可以用来将数据集分割为训练集、验证集和测试集的技术。

数据集的分割

在本节中，我们将学习如何轻松分割数据集以支持 BigQuery ML 模型的训练、验证和测试阶段。

对于大多数 BigQuery ML 算法，我们需要将初始数据集分为三个不同的集合，如下所示：

训练数据集代表我们将用于训练我们的 BigQuery ML 模型的样本数据。
验证集与训练集不同，我们可以用它来评估模型的性能。我们在与训练阶段使用的样本数据完全不同的新数据上执行验证。在这个阶段，我们还可以调整模型的超参数。
测试集是用于最终应用模型并验证其结果和性能的数据集。

将初始数据集分割成这三个子集可能会很繁琐，但如果您有足够的数据，可以应用以下经验规则：

训练集的数据占 80%。
10% 用于验证集。
剩余的 10% 用于测试集。
如果我们在处理大量数据，我们可以减少用于验证集和测试集的观测值的百分比。

在以下屏幕截图中，您可以看到最佳分割策略的图形表示：

图 14.8 – 机器学习的 80/10/10 分割策略

为了达到最佳结果，分割过程应该尽可能随机。

在以下代码块中，您可以看到如何通过使用 MOD 函数应用此经验规则：

SELECT
  CASE
    WHEN MOD(<RECORD_KEY>, 10) < 8 THEN 'training'
    WHEN MOD(<RECORD_KEY>, 10) = 8 THEN 'evaluation'
    WHEN MOD(<RECORD_KEY>, 10) = 9 THEN 'test'
  END AS dataframe
FROM
  <TABLE_NAME>

在示例中，存储在由占位符 <TABLE_NAME> 表示的表中的记录根据字段 dataframe 的值分为三个不同的集合。在这种情况下，MOD 函数返回一个从 0 到 10 的值。使用此函数允许我们将记录分为三个不同的集合。通过利用 MOD(<RECORD_KEY>, 10)<8, MOD(<RECORD_KEY>, 10) = 8 和 MOD(<RECORD_KEY>, 10) = 9 这两个子句，我们可以将记录分为 'training'、'evaluation' 和 'test' 集合。

现在我们已经了解了如何根据我们的训练、验证和测试需求来分割数据集，让我们来看看对特征工程技术的理解。

理解特征工程

在本节中，我们将了解在训练阶段之前我们可以使用哪些技术来改进 BigQuery ML 模型的特征。

重要提示

特征工程是在原始数据上应用预处理函数的实践，以提取对训练机器学习模型有用的特征。创建预处理特征可以显著提高机器学习模型的性能。

按照设计，BigQuery ML 在使用 CREATE MODEL 函数进行训练阶段时，会自动应用特征工程，但它也允许我们应用预处理转换。

为了在训练和预测阶段自动应用特征工程操作，我们可以在训练 BigQuery ML 模型时将所有预处理函数包含在 TRANSFORM 子句中。

如以下代码示例所示，我们需要在 OPTIONS 子句之前使用 TRANSFORM 子句，并在 CREATE MODEL 语句之后：

CREATE MODEL <MODEL_NAME>
TRANSFORM(<TRANSFORM_CLAUSES>)
OPTIONS
  (<OPTION_CLAUSES>) AS
<TRAINING_TABLE>

在 BigQuery ML 中，有两种不同类型的特征工程函数，如下所述：

标量函数作用于单个记录
分析性函数在所有行上计算结果

在以下列表中，您可以查看在 BigQuery ML 中可以应用的最重要特征工程函数：

ML.BUCKETIZE: 这个函数用于将数值表达式转换为分类字段——例如，您可以使用此函数将一个人的年龄转换为 Young（年轻）、Middle（中年）或 Old（老年）桶。
ML.FEATURE_CROSS: 这个函数用于将两个特征组合成一个独特的特征。例如，如果在数据集中我们有一个人的性别和出生地，我们可以将这些两个特征组合起来简化我们的 BigQuery ML 模型。当我们在相关特征中并且想要在我们的机器学习模型中包含这两个信息时，这种技术特别适用。
ML.QUANTILE_BUCKETIZE: 这个函数与 ML.BUCKETIZE 函数非常相似。在这种情况下，该函数是分析性的，并应用于数据集中的所有记录。记录分割成桶是基于整个记录集的百分位数。

重要提示

分位数是数据集的特定部分。例如，它标识有多少值高于或低于某个阈值。
ML.MIN_MAX_SCALER: 这是一个分析函数，根据整个记录集中的值分布返回一个从零到一的值。
ML.STANDARD_SCALER: 这是一个分析函数，允许我们使用记录集的标准差和平均值。

对于特征工程和预处理的完整函数列表，您可以访问以下链接的官方 BigQuery 文档：cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-preprocessing-functions。

现在我们已经了解了特征工程，让我们继续学习超参数调整。

调整超参数

在本节中，我们将探讨在 BigQuery ML 中可以调整的最重要超参数。

重要提示

超参数调整是选择最佳参数集以训练特定机器学习模型的实践。超参数在机器学习训练阶段影响并控制学习过程。

按设计，BigQuery ML 使用默认超参数来训练模型，但高级用户可以手动更改它们以影响训练过程。

在 BigQuery ML 中，我们可以在 OPTIONS 子句中指定超参数作为可选参数。在开始训练 BigQuery ML 模型之前，我们可以更改的最相关的超参数（取决于模型）如下所示：

L1_REG: 这是一个正则化参数，我们可以使用它通过保持模型权重接近零来防止过拟合。
L2_REG: 这是一个第二正则化参数，我们可以使用它来防止过拟合。
MAX_ITERATIONS：这代表 BigQuery ML 在训练模型时将执行的最大迭代次数。
LEARN_RATE：这是一个参数，它影响模型根据前一次迭代的错误进行多少变化。
MIN_REL_PROGRESS：这是在迭代后继续训练所必需的最小改进。
NUM_CLUSTERS：这用于 K-Means 算法，表示模型将创建的簇的数量。
HIDDEN_UNITS：这用于深度神经网络（DNNs），表示网络中的隐藏层数量。

关于你可以使用 BigQuery ML 应用的所有超参数的完整列表，我们建议访问官方文档cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create。

使用 BigQuery ML 进行在线预测

在本节中，我们将了解如何以同步和在线的方式使用 BigQuery ML 模型。

BigQuery ML 为商业和数据分析师民主化机器学习技术提供了巨大的机会。当 BigQuery ML 训练并准备好使用时，我们可以在 BigQuery 中直接通过 SQL 查询调用它，或者将其导出到 TensorFlow 格式。

每个用例的需求驱动我们应该采用的预测类型，如下所述：

当我们想要启用请求-响应应用程序，并且获取即时预测至关重要时，我们使用在线预测。
当我们不需要立即预测时，我们会采用批量预测来处理大量数据——例如，安排每日或每周的工作，计算自上次作业执行以来收集的数据的预测。

虽然使用 BigQuery SQL 语句更适合对存储在 BigQuery 表中的大量记录进行批量预测，但将 BigQuery ML 模型导出到 TensorFlow 的可能性为应用开辟了新的机会。

在下面的图中，你可以看到 BigQuery ML 模型从训练阶段到部署阶段的生命周期：

图 14.9 – 使用 BigQuery ML 模型进行在线预测

从前面的图中，我们看到在 BigQuery ML 模型生命周期的第一步（1）中，我们通过利用存储在 BigQuery 中的训练数据集来训练 ML 模型。在这个第一步中，ML 模型经历了开发周期的三个主要阶段，如下所述：

训练：在这个阶段，BigQuery ML 模型从训练数据中学习。
评估：在这个步骤中，我们评估模型的 KPI 指标，并且可以调整超参数。
测试：在这个最后阶段，我们最终在测试数据集上测试 BigQuery ML 模型以获取预测。

当 BigQuery ML 模型在性能方面满足我们的期望时，我们可以做以下操作：

通过 SQL 在 BigQuery 中使用模型（2a），通过利用已存储在表中的数据。这种方法通常适用于批量预测——例如，我们可以定期运行 BigQuery SQL 语句，每天或每周执行模型，生成新的预测。
将模型导出到 TensorFlow 的SavedFormat**（2b）**，正如我们在第十三章，“使用 BigQuery ML 运行 TensorFlow 模型”中描述的那样。这种方法特别适合在 BigQuery 之外的其他 TensorFlow 兼容平台上运行机器学习模型。同样的方法可以通过将机器学习模型导出到 XGBoost 增强器格式来采用。

当我们导出 BigQuery ML 模型后，我们可以将机器学习算法部署到以下之一：

Google Cloud AI Platform Prediction （3a）：使用这个 Google Cloud 模块，我们可以在云中部署训练好的机器学习模型，并利用云基础设施来提供模型和生成在线预测。这种云服务自动配置和管理基础设施资源以运行机器学习模型，并且可以根据来自客户端应用程序的请求数量进行扩展。在 Google Cloud AI Platform Prediction 上的部署会自动生成一个表示状态传输 (REST)端点，可以通过超文本传输协议 (HTTP)请求来调用模型。

这种方法在当我们有多个客户端应用程序需要与我们的机器学习模型交互，而我们又不想担心服务的基础设施维护时特别有用。作为先决条件，我们需要考虑的是，我们只能在使用互联网连接的情况下使用这种方法。实际上，为了调用云平台暴露的 REST 应用程序编程接口 (API)，我们需要从客户端应用程序向云发送 HTTP 请求。
一种可以在本地机器上部署使用容器的（3b）方法。TensorFlow 模型实际上可以通过利用TensorFlow Serving Docker容器来部署。要了解在Docker容器中部署 TensorFlow 模型的步骤，您可以查看www.tensorflow.org/tfx/serving/docker上的文档。

重要提示

容器是一种在单个操作系统之上运行的虚拟化机制。Docker是一个用于部署容器化应用程序的容器引擎。容器引擎为每个应用程序分配硬件资源，并管理虚拟基础设施的可伸缩性。

当机器学习模型需要在特定条件下运行时，例如在无互联网连接或敏感数据的情况下，我们可以使用这种方法。实际上，当我们部署本地机器学习模型时，云基础设施不再参与预测，并且本地环境和云之间没有数据传输。

在这两种部署场景中，可以通过使用 HTTP 请求调用 ML 模型，在请求有效负载中传递输入参数。在 ML 模型执行结束时，预测结果返回到响应有效负载中。

摘要

在本章中，我们学习了在实施 BigQuery ML 机器学习用例时可以应用的最重要技巧和最佳实践。

我们分析了数据准备的重要性；我们开始关注数据质量方面；然后，我们学习了如何轻松地将数据分割以获得平衡的训练、验证和测试集。

然后，我们探讨了如何使用 BigQuery ML 的函数来改进机器学习模型的表现。

之后，我们专注于调整超参数。当我们训练模型时，BigQuery ML 允许我们选择不同的参数，这些变量影响训练阶段。

最后，我们理解了为什么在其它平台上部署 BigQuery ML 模型如此重要，以便我们获得在线预测并满足近实时业务场景。

恭喜您完成本书的阅读！现在您应该能够为您的业务场景和用例使用 BigQuery ML。我建议您继续关注这个如此有趣且发展迅速的主题。

龙哥盟

掠夺·扩张·投机·博弈

BigQueryML-机器学习-全-

BigQueryML 机器学习（全）

前言

本书面向对象

本书涵盖内容

要充分利用本书

下载示例代码文件

代码实战

下载彩色图像

使用的约定

联系我们

评论

第一部分：简介和环境设置

第一章：Google Cloud 和 BigQuery 简介

介绍 Google Cloud Platform

与 GCP 交互

发现 GCP 的关键差异化特点

安全

全球网络和基础设施

无服务器和完全托管方法

环境可持续性

普及人工智能

探索 GCP 上的 AI 和 ML 服务

核心平台服务

处理单元（CPU、GPU 和 TPU）

深度学习 VM 镜像

TensorFlow

AI 平台

AI 平台 Notebooks

构建模块

AutoML

预构建 API

BigQuery ML

解决方案

AI Hub

Cloud Talent Solution

接触中心 AI

文档 AI

介绍 BigQuery

BigQuery 架构

存储层

计算层（查询层）

BigQuery 相比传统数据仓库的优势

无服务器

可扩展性

可用性

性能

实时性

格式灵活性

创新功能

安全性

与其他 GCP 服务的集成

丰富的合作伙伴生态系统

公共数据集

与 BigQuery 交互

BigQuery 数据结构

发现 BigQuery ML

BigQuery ML 优势

BigQuery ML 算法

理解 BigQuery 定价

BigQuery 定价

存储

计算资源

流式传输

BigQuery ML 定价

免费操作和免费层

价格计算器

摘要

进一步资源

第二章：设置您的 GCP 和 BigQuery 环境

技术要求

创建您的 GCP 账户和项目

注册 GCP 帐户

探索 Google Cloud Console

创建 GCP 项目

激活 BigQuery

发现 BigQuery 网络用户界面

探索 BigQuery 公共数据集