AutoKeras-自动机器学习-全-

AutoKeras 自动机器学习（全）

原文：annas-archive.org/md5/4b95d582294fbab3113a489dde33e6e5

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

深度学习能否普及到每个人？毫无疑问，这是 Google 或 Amazon 等科技巨头提供的云服务所试图实现的目标。Google AutoML 和 Amazon ML 服务是基于云的服务，使所有技术水平的开发者都能轻松使用机器学习技术。AutoKeras 是免费的开源替代方案，正如我们很快将看到的，它是一个非常棒的框架。

面对深度学习问题时，选择架构或配置创建模型时的某些参数，通常来源于数据科学家的直觉，这种直觉是基于多年的学习和经验。

对于我来说，作为一名没有广泛数据科学背景的软件工程师，我一直在寻找方法来自动化这一部分，使用不同的搜索算法（网格搜索、进化算法或贝叶斯方法）来探索构成模型的不同变量。

像许多其他 Python 开发者一样，我开始涉足机器学习世界时使用的是 scikit-learn，后来又转向了 TensorFlow 和 Keras 的深度学习项目，测试了 Hyperas 或 TPOT 等不同框架来自动化模型生成，甚至开发了一个用来在 Keras 模型中探索架构的工具。但一旦 AutoKeras 发布，我发现它满足了我所有的需求，从那时起我便开始使用它并为该项目做出贡献。

AutoKeras 拥有一个日益壮大的社区，并得到了广受欢迎的深度学习框架 Keras 的支持，但除了它的文档和偶尔的博客文章，至今几乎没有关于它的书籍——本书旨在填补这一空白。

本书和框架面向广泛的机器学习专业人士，从寻找云服务替代方案的初学者（仅通过定义输入和输出作为黑盒使用）到希望通过详细定义搜索空间参数并将生成的模型导出到 Keras 进行手动微调的经验丰富的数据科学家。如果你是前者，这些术语和概念可能会让你感到陌生，但不要担心，我们将在全书中详细解释。

本书适合人群

本书面向希望将自动化机器学习技术应用于项目的机器学习和深度学习爱好者。为了充分利用本书内容，读者需要具备一定的 Python 编程基础知识。

本书涵盖的内容

第一章，自动化机器学习简介，涵盖了自动化机器学习的主要概念，并概述了各种 AutoML 方法及其软件系统。

第二章，AutoKeras 入门，涵盖了你开始使用 AutoKeras 所需的所有内容，并通过一个基础且解释清晰的代码示例，帮助你将其付诸实践。

第三章，使用 AutoKeras 自动化机器学习管道，解释了标准的机器学习管道，讲解了如何使用 AutoKeras 自动化此管道，并描述了在训练模型之前应用的主要数据准备最佳实践。

第四章，使用 AutoKeras 进行图像分类和回归，专注于将 AutoKeras 应用于图像，通过创建更复杂、更强大的图像识别器，研究它们的工作原理，并演示如何调整它们以提高性能。

第五章，使用 AutoKeras 进行文本分类和回归，重点介绍了使用 AutoKeras 处理文本（单词序列）。本章还解释了什么是递归神经网络以及它们如何工作。

第六章，使用 AutoKeras 处理结构化数据，使你能够探索结构化数据集、进行转换，并将其用作特定模型的数据源，还可以创建自己的分类和回归模型来解决基于结构化数据的任务。

第七章，使用 AutoKeras 进行情感分析，使用文本分类器从文本数据中提取情感，并通过实现情感预测器，实际应用文本分类的概念。

第八章，使用 AutoKeras 进行主题分类，专注于前几章学习的基于文本的任务的实际应用。它教你如何使用 AutoKeras 创建一个主题分类器，并将其应用于任何主题或类别的数据集。

第九章，处理多模态数据和多任务，介绍了如何使用 AutoModel API 来处理多模态和多任务数据。

第十章，导出和可视化模型，教你如何导出和导入 AutoKeras 模型，并图形化展示模型训练过程中的实时变化。

要最大限度地发挥本书的价值

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

下载示例代码文件

你可以从 GitHub 下载本书的示例代码文件，地址为github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。如果代码有更新，将在现有的 GitHub 仓库中进行更新。

我们还提供了来自我们丰富书籍和视频目录的其他代码包，您可以在github.com/PacktPublishing/查看。快来看看吧！

下载彩色图片

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

使用的约定

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

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

一段代码块如下所示：

import autokeras as ak 
import matplotlib.pyplot as plt 
import numpy as np 
import tensorflow as tf 
from tensorflow.keras.datasets import mnist 

当我们希望特别指出代码块的某部分时，相关行或项目会以粗体显示：

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

所有命令行输入或输出如下所示：

$ mkdir css
$ cd css

粗体：表示新术语、重要单词或在屏幕上看到的单词。例如，菜单或对话框中的单词以这种方式出现在文本中。示例："用于训练模型的训练数据集和用于测试预测模型的测试数据集"。

注意

笔记本是由 Jupyter Notebook（https://jupyter.org）生成的文件，Jupyter Notebook 是一个开源框架，用于创建和共享文档，结合了实时代码、可视化和富文本。编辑和执行都在网页浏览器中完成，可以添加代码和富文本片段（称为单元格），清晰、直观地展示所编写的代码。每个代码单元都可以独立运行，开发过程具有互动性，避免在发生错误时需要重新运行所有代码。

联系我们

我们欢迎读者的反馈。

一般反馈：如果您对本书的任何部分有疑问，请在邮件主题中注明书名，并通过 customercare@packtpub.com 联系我们。

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

盗版：如果您在互联网上遇到我们作品的任何非法副本，请提供其位置地址或网站名称。请通过 copyright@packt.com 联系我们，并附上相关链接。

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

评论

请留下评论。在您阅读并使用本书之后，为什么不在您购买它的站点上留下评论呢？潜在读者可以看到并参考您的客观意见来做出购买决策，我们在 Packt 也能了解您对我们产品的看法，而我们的作者可以看到您对他们书籍的反馈。谢谢！

欲了解更多关于 Packt 的信息，请访问packt.com。

第一部分：AutoML 基础

本节是对自动化机器学习的高级介绍，解释了开始使用这种机器学习方法所需的所有概念。

本节包含以下章节：

• 第一章**，自动化机器学习简介

• 第二章**，使用 AutoKeras 入门

• 第三章**，使用 AutoKeras 自动化机器学习管道

第一章：第一章：自动化机器学习概述

在本章中，我们将介绍与自动化机器学习（AutoML）相关的主要概念，并概述不同类型的 AutoML 方法及其软件系统。

如果您是一位从事 AutoML 的开发人员，您将能够利用这本实用指南，在项目中开发和使用最先进的 AI 算法。到本章结束时，您将清楚了解机器学习（ML）工作流的结构、AutoML 的定义及其不同类型。

通过对基本概念的清晰解释和实际示例，您将看到标准 ML 方法与 AutoML 方法的差异，以及各自的优缺点。

本章将涵盖以下主要内容：

• 标准 ML 工作流的结构

• 什么是 AutoML？

• AutoML 的类型

标准 ML 工作流的结构

在传统的 ML 应用中，专业人员需要使用一组输入数据来训练模型。如果这些数据不符合正确的格式，专家可能需要应用一些数据预处理技术，如特征提取、特征工程或特征选择。

一旦数据准备好并且模型可以进行训练，下一步就是选择合适的算法并优化超参数，以最大化模型预测的准确性。每个步骤都涉及耗时的挑战，并且通常还需要具备经验和知识的数据科学家才能成功完成。下图中，我们可以看到典型 ML 流水线中的主要步骤：

图 1.1 – ML 流水线步骤

每个流水线过程都涉及一系列步骤。在接下来的章节中，我们将更详细地描述每个过程及其相关概念。

数据摄取

将传入数据传输到数据存储是任何 ML 工作流中的第一步。这里的目标是将原始数据存储起来，不进行任何转换，以便保留原始数据集的不可变记录。数据可以来自各种数据源，如数据库、消息总线、流等。

数据预处理

第二阶段，数据预处理，是流水线中最耗时的任务之一，并涉及许多子任务，如数据清洗、特征提取、特征选择、特征工程和数据分割。让我们仔细看看每个子任务：

• 数据清洗过程负责检测和修复（或删除）数据集中存在的错误或损坏的记录。由于数据是未经处理且无结构的，通常不符合处理的正确形式；这意味着需要填补缺失的字段、删除重复的行，或规范化并修复数据中的其他错误。

• 特征提取是通过将多个特征组合成新特征来减少大数据集所需资源的过程，并且可以删除原始特征。分析大数据集时的主要问题是需要考虑的变量数量。处理大量变量通常需要大量硬件资源，如内存和计算能力，并且可能导致过拟合，这意味着算法对训练样本表现很好，但对新样本的泛化能力较差。特征提取基于构建新变量，结合现有变量，解决这些问题，而不会丢失数据的精度。

• 特征选择是选择一组变量来用于构建模型的过程。进行特征选择可以简化模型（使其对人类更具可解释性），减少训练时间，并通过减少过拟合来提高泛化能力。应用特征选择方法的主要原因是，数据中可能包含一些冗余或无关的特征，因此删除这些特征不会造成太大的信息损失。

• 特征工程是通过数据挖掘技术，利用领域知识从原始数据中提取特征的过程。通常需要一位专业的专家，并且用于提升机器学习算法的性能。

数据分割是将数据集划分为两个子集：一个用于训练模型的训练数据集和一个用于测试预测模型的测试数据集。

建模分为三个部分：

1. 选择候选模型进行评估。

2. 训练所选择的模型（提高其性能）。

3. 评估模型（与其他模型进行比较）。

这个过程是迭代的，涉及测试各种模型，直到找到一种能够高效解决问题的模型。下图展示了 ML 流水线建模阶段的详细框架：

图 1.2 – ML 流水线建模阶段

在概述建模阶段后，让我们更详细地了解每个建模步骤。

让我们更深入地探讨建模的三个部分，以便对它们有更详细的理解。

模型选择

在选择候选模型时，除了考虑性能外，还需要考虑几个因素，如可读性（人类可读性）、调试便捷性、可用数据量以及用于训练和预测的硬件限制。

选择模型时需要考虑的主要点如下：

• 可解释性和调试便捷性：如何了解模型为什么做出特定决策。我们如何修正错误？

• 数据集类型：某些算法更适合特定类型的数据。

• 数据集大小：可用数据量是多少？将来是否会发生变化？

• 资源：你为训练和预测准备了多少时间和资源？

模型训练

这个过程使用训练数据集来为每个选定的候选模型提供数据，让模型通过应用反向传播算法，从训练样本中提取出模式进行学习。

模型通过数据预处理步骤的输出数据进行训练。该数据集被发送到选定的模型，训练完成后，模型配置和学习到的参数将用于模型评估。

模型评估

这一步负责使用测试数据集评估模型性能，以衡量预测的准确性。这个过程包括调整和改进模型，生成新的候选模型版本以重新训练。

模型调优

这个模型评估步骤包括修改超参数，例如学习率、优化算法或模型特定的架构参数，如神经网络的层数和操作类型。在标准的机器学习中，这些步骤通常需要专家手动执行。

其他时候，评估过的模型会被丢弃，选择另一个新的模型进行训练。通常，通过迁移学习从先前训练的模型开始，能缩短训练时间，并提高最终模型预测的精度。

由于主要瓶颈是训练时间，因此模型的调整应关注效率和可复现性，以便训练尽可能快速，并且其他人能够复现已经采取的步骤来提升性能。

模型部署

一旦选定最佳模型，通常通过 API 服务将其投入生产，以便最终用户或其他内部服务使用。

通常，最佳模型会被选择以在两种部署模式之一中部署：

• 离线（异步）：在这种情况下，模型预测是在定期的批处理过程中计算的，并作为键值数据库存储在数据仓库中。

• 在线（同步）：在这种模式下，预测是在实时计算中进行的。

部署包括将模型暴露给实际应用。这个应用可以是任何东西，从向流媒体平台的用户推荐视频，到在移动应用上预测天气。

将机器学习模型发布到生产环境是一个复杂的过程，通常涉及多种技术（版本控制、容器化、缓存、热交换、A/B 测试等），且超出了本书的讨论范围。

模型监控

一旦进入生产环境，模型会被监控，以查看它在现实世界中的表现，并根据需要进行校准。这个架构表示了持续的模型周期，从数据摄取到部署：

图 1.3 – 模型周期阶段

在接下来的章节中，我们将解释监控生产模型的主要原因。

为什么要监控你的模型？

你的模型预测会随着时间的推移而下降。这种现象称为漂移。漂移是输入数据变化的结果，因此随着时间的推移，预测自然会变得更差。

让我们以搜索引擎的用户为例。一个预测模型可以利用用户特征，如个人信息、搜索类型和点击的结果来预测展示哪些广告。但过了一段时间，这些搜索可能不再代表当前的用户行为。

一个可能的解决方案是用最新的数据重新训练模型，但这并不总是可行的，有时甚至可能适得其反。假设用 COVID-19 疫情初期的搜索数据来训练模型，这样只会展示与疫情相关的广告，导致其他产品的销量急剧下降。

对抗漂移的一个更智能的替代方法是监控我们的模型，通过了解发生了什么，我们可以决定何时以及如何重新训练模型。

如何监控你的模型？

在有实际值可以及时与预测进行对比的情况下——我的意思是，在做出预测后，你立刻就能得到真实标签——你只需要监控准确率、F1 分数等性能指标。然而，通常预测与真实情况之间会有延迟；例如，在预测邮件是否为垃圾邮件时，用户可能会在邮件创建后的几个月才报告某封邮件为垃圾邮件。在这种情况下，你必须使用基于统计方法的其他度量方法。

对于其他复杂的过程，有时候进行流量/案例拆分并监控纯业务指标会更容易，尤其是在很难考虑经典机器学习评估指标与现实世界实例之间的直接关系的情况下。

你应该在模型中监控什么？

任何机器学习管道都涉及性能数据监控。以下是一些可能需要监控的模型变量：

• 选择的模型：选择了哪种类型的模型，它的架构类型、优化算法和超参数值是什么？

• 输入数据分布：通过将训练数据的分布与输入数据的分布进行比较，我们可以检测出用于训练的数据是否代表了当前真实世界中的情况。

• 部署日期：模型发布的日期。

• 使用的特征：作为模型输入的变量。有时，生产环境中有一些相关特征，但我们没有在模型中使用它们。

• 预期与实际：通过散点图比较预期值和实际值，这通常是最广泛使用的方法。

• 发布次数：模型发布的次数，通常用模型版本号表示。

• 运行时间：自模型部署以来已经过去多久？

现在我们已经看过管道的不同组件，准备好在下一节介绍主要的 AutoML 概念了。

什么是 AutoML？

在建模阶段的主要任务是选择要评估的不同模型，并调整每个模型的不同超参数。数据科学家通常需要花费大量时间并拥有丰富经验才能完成这些工作。从计算角度来看，超参数调优是一个全面的搜索过程，因此可以自动化。

AutoML是一个自动化的过程，利用人工智能算法自动执行先前描述的机器学习流程中的每一个步骤，从数据预处理到机器学习模型的部署，使非数据科学家（如软件开发人员）也能使用机器学习技术，而无需该领域的经验。在下图中，我们可以看到 AutoML 系统的输入和输出的简单表示：

图 1.4 – AutoML 的工作原理

AutoML 还能够生成更简单的解决方案，更灵活的概念验证创建，以及无人值守的模型训练，这些模型通常优于手动创建的模型，显著提高模型的预测性能，并使数据科学家能够执行更复杂、难以自动化的任务，例如数据预处理和特征工程，这些任务在模型监控部分有定义。在介绍 AutoML 的类型之前，先快速了解一下 AutoML 与传统机器学习的主要区别。

与标准方法的区别

在标准的机器学习方法中，数据科学家有一个输入数据集来进行训练。通常，这些原始数据并未准备好供训练算法使用，因此专家必须应用不同的方法，如数据预处理、特征工程和特征提取方法，并通过算法选择和超参数优化来调整模型，以最大化模型的预测性能。

所有这些步骤都耗时且资源密集，是将机器学习（ML）应用到实际中的主要障碍。

通过 AutoML，我们简化了这些步骤，使非专家也能以更简便、更快速的方式应用机器学习解决问题。

既然已经解释了 AutoML 的主要概念，我们可以将其付诸实践。但首先，我们将了解 AutoML 的主要类型以及一些广泛使用的工具来执行 AutoML。

AutoML 的类型

本章将探讨当前为每种先前列出的 AutoML 类型提供的框架，让您了解目前在 AutoML 方面可以实现的内容。但首先，让我们简要讨论一下端到端机器学习流程，并看看每个过程在该流程中发生的位置。

正如我们在之前的工作流程图中看到的，机器学习流水线涉及比建模更多的步骤，如数据步骤和部署步骤。在本书中，我们将专注于建模的自动化，因为这是一个需要更多时间投入的阶段，正如我们稍后将看到的，AutoKeras，我们将使用的 AutoML 框架，使用了神经架构搜索和超参数优化方法，这两者都应用在建模阶段。

AutoML 试图自动化管道中的每个步骤，但通常需要自动化的主要耗时步骤如下：

• 自动特征工程

• 自动模型选择和超参数调整

• 自动神经网络架构选择

自动特征工程

模型使用的特征直接影响机器学习算法的性能。特征工程需要大量时间和人力资源（数据科学家），并涉及大量的试验和错误，以及深入的领域知识。

自动特征工程基于迭代地创建新的特征集，直到机器学习模型达到良好的预测性能。

在标准的特征工程过程中，例如从一个职位搜索网站收集的数据集中，通常数据科学家会创建新的特征（如果数据中还没有），例如以下内容：

• 搜索关键字

• 候选人阅读的职位名称

• 候选人申请频率

• 上次申请以来的时间

• 候选人申请的职位类型

特征工程自动化尝试创建一种算法，该算法可以自动从数据中生成或获取这些类型的特征。

还有一种称为深度学习的专门形式的机器学习，其中特征是通过在模型层上的矩阵变换自动从图像、文本和视频中提取的。

自动模型选择和超参数优化

在数据预处理阶段之后，需要搜索一个机器学习算法来训练这些特征，以便能够预测新的观测结果。与前一步骤相比，模型选择有很多可供选择的选项。有分类和回归模型，基于神经网络的模型，聚类模型等等。

每种算法适用于某类问题，通过自动化模型选择，我们可以执行所有适合特定任务的适当模型，并选择最准确的模型。没有一种机器学习算法适用于所有数据集，有些算法需要比其他算法更多的超参数调整。事实上，在模型选择过程中，我们倾向于尝试不同的超参数。

什么是超参数？

在模型的训练阶段，有许多变量需要设置。基本上，我们可以将它们分为两类：参数和超参数。参数是在模型训练过程中学习到的，例如神经网络中的权重和偏置，而超参数是在训练过程开始前初始化的，例如学习率、丢弃率等。

搜索方法类型

有许多算法可以找到模型的最优超参数。下图突出显示了最著名的几种算法，这些算法也被 AutoKeras 使用：

图 1.5 – 超参数搜索方法路径

让我们更详细地理解这些方法：

• 网格搜索：给定一组变量（超参数）和每个变量的值集合，网格搜索执行一种穷尽搜索，测试这些值在变量中的所有可能组合，以根据定义的评估标准（如精度）找到最佳的模型。在一个神经网络中，假设学习率和丢弃率作为超参数进行调整，我们可以将学习率的值集合定义为[0.1, 0.01]，丢弃率的值集合定义为[0.2, 0.5]，因此网格搜索将使用这些组合训练模型：

  (a) 学习率：0.1，丢弃率=0.2 => 模型版本 1

  (b) 学习率：0.01，丢弃率=0.2 => 模型版本 2

  (c) 学习率：0.1，丢弃率=0.5 => 模型版本 3

  (d) 学习率：0.01，丢弃率=0.5 => 模型版本 4

• 随机搜索：这与网格搜索类似，但它以随机顺序运行模型组合的训练。由于其随机探索特性，随机搜索通常比网格搜索便宜。

• 贝叶斯搜索：该方法基于贝叶斯定理执行超参数拟合，只探索那些最大化概率函数的组合。

• Hyperband：这是一种新型的随机搜索变体，尝试通过基于老丨虎丨机的方法解决探索/利用困境，以进行超参数优化。

自动化神经网络架构选择

神经网络架构的设计是机器学习领域最复杂和最繁琐的任务之一。通常，在传统机器学习中，数据科学家会花费大量时间迭代不同的神经网络架构和超参数，以优化模型的目标函数。这既耗时，又需要深厚的知识，有时还容易出错。

在 2010 年代中期，提出了通过使用进化算法和强化学习来设计和寻找最优神经网络架构的想法。这被称为网络架构搜索（NAS）。基本上，它训练一个模型来创建层，并堆叠这些层以构建一个深度神经网络架构。

一个 NAS 系统包括以下三个主要组件：

• 搜索空间：由一组操作块（全连接、卷积等）以及这些操作如何相互连接以形成有效的网络架构组成。传统上，搜索空间的设计由数据科学家完成。

• 搜索算法：NAS 搜索算法测试一系列候选网络架构模型。从获得的指标中，它选择表现最好的候选模型。

• 评估策略：为了获得成功的结果，需要测试大量的模型，因此该过程在计算上非常昂贵，因此新的方法时常出现，以节省时间或计算资源。

在下一个图中，你可以看到三个描述的组件之间的关系：

图 1.6 – NAS 组件关系

目前，NAS 是一个新兴的研究领域，吸引了大量关注，并且已经发布了若干研究论文：www.ml4aad.org/automl/literature-on-neural-architecture-search/。以下是一些被引用最多的论文：

• NASNet (arxiv.org/abs/1707.07012) – 可转移架构的学习用于可扩展图像识别：基于非常复杂的神经网络（具有大量层）的高精度图像分类模型。NASNet 是一种直接从感兴趣的数据集学习模型架构的方法。由于在数据集非常大的情况下，执行该操作的成本很高，因此它首先在一个小数据集中寻找架构构建模块，然后将该模块转移到更大的数据集上。这种方法是 AutoML 成功应用的一个典范，因为 NASNet 生成的模型通常优于最先进的人工设计模型。在下图中，我们可以看到 NASNet 是如何工作的：

图 1.7 – NAS 概览

• AmoebaNet – 图像分类器架构搜索的正则化进化：该方法使用进化算法高效地发现高质量的架构。迄今为止，应用于图像分类的进化算法尚未超越人工设计的架构。而 AmoebaNet-A 首次超越了这些架构。关键在于通过引入年龄属性来修改选择算法，偏向选择最年轻的基因型。AmoebaNet-A 的精度与采用更复杂架构搜索方法发现的最新一代 ImageNet 模型相似，表明进化算法能够在相同硬件上更快地取得结果，特别是在搜索的早期阶段，这在计算资源有限时尤为重要。下图展示了历史上一些代表性的下一代图像分类模型的精度与模型大小之间的相关性。虚线圆圈显示了 AmoebaNet 模型的 84.3% 精度：

图 1.8 – 使用 ImageNet 数据集的最先进图像分类模型中，top-1 精度与模型大小之间的相关性

• Efficient Neural Architecture Search (ENAS)：该 NASNet 的变种通过允许所有子模型共享权重，避免每个子模型从头开始训练，从而提高了效率。这一优化显著提高了分类性能。

有许多机器学习工具可用，它们的目标都相似，旨在自动化机器学习管道的不同步骤。以下是一些最常用的工具：

• AutoKeras：一个基于深度学习框架 Keras 的 AutoML 系统，采用超参数搜索和神经架构搜索（NAS）。

• auto-sklearn：一个 AutoML 工具包，允许你使用一种特殊类型的 scikit-learn 估算器，自动选择算法和调整超参数，使用贝叶斯优化、元学习和模型集成。

• DataRobot：一个 AI 平台，自动化构建、部署和维护大规模 AI 的端到端过程。

• Darwin：一个 AI 工具，自动化模型生命周期中最慢的步骤，确保模型的长期质量和可扩展性。

• H2O-DriverlessAI：一个 AutoML 的 AI 平台。

• Google's AutoML：一套机器学习产品，使没有机器学习经验的开发人员也能在项目中训练和使用高性能模型。为此，该工具采用了 Google 强大的下一代迁移学习和神经架构搜索技术。

• Microsoft Azure AutoML：此云服务并行创建多个管道，尝试不同的算法和参数。

• 基于树的管道优化工具 (TPOT): 一个 Python 自动化机器学习工具，使用遗传编程优化机器学习管道。

我们可以在论文《AutoML 方法与工具的评估与比较》中看到目前存在的主要 AutoML 工具的详尽比较，从中我们可以得出结论，虽然主要的商业解决方案，如 H2O-DriverlessAI、DataRobot 和 Darwin，允许我们检测数据架构、执行特征工程，并分析详细结果以供解释，但开源工具则更多专注于自动化建模任务、训练和模型评估，将数据相关的任务留给数据科学家。

研究还得出结论，在各种评估和基准测试中，AutoKeras 是最稳定和高效的工具，这在生产环境中非常重要，因为在这种环境中，性能和稳定性是关键因素。这些优良特性，加上它是一个广泛使用的工具，是选择 AutoKeras 作为本书编写时所选 AutoML 框架的主要原因。

摘要

在本章中，我们定义了 AutoML 的目的和好处，从描述 ML 管道的不同阶段到详细说明超参数优化和神经架构搜索的算法类型。

现在我们已经了解了 AutoML 的主要概念，准备进入下一章，您将在那里学习如何安装 AutoKeras，如何使用它训练一个简单的网络，并随着学习更复杂的技术，训练更高级的模型。

进一步阅读

• 贝叶斯定理: towardsdatascience.com/bayes-theorem-the-holy-grail-of-data-science-55d93315defb

• 探索与利用的困境: towardsdatascience.com/intuition-exploration-vs-exploitation-c645a1d37c7a

• 多臂赌博机: homes.di.unimi.it/~cesabian/Pubblicazioni/ml-02.pdf

• AmoebaNet: arxiv.org/abs/1802.01548

• ENAS: arxiv.org/abs/1802.03268

• AutoML 方法与工具的评估与比较: arxiv.org/pdf/1908.05557.pdf

第二章：第二章：开始使用 AutoKeras

在这一章中，我们将介绍你需要了解的一切，以便开始使用AutoKeras并通过一个基础且讲解充分的代码示例将其付诸实践。在本章结束时，你将知道如何用几行代码创建一个简单的手写数字分类器，数据来源于广为人知的修改版国家标准与技术研究所（MNIST）数据集。

正如我们在上一章看到的那样，深度学习（DL）自动化能够加快训练时间，并且通过将人力资源（数据科学家）分配到其他不太可能被自动化的管道流程中，获得更多好处。

为了实现这一自动化，我们选择了 AutoKeras。它是一个基于Keras的机器学习（ML）自动化框架，Keras是一个广为人知的基于TensorFlow的神经网络库，提供了构建深度学习模型的高级模块。

接下来，我们将介绍如何安装 AutoKeras，并通过一个实际示例将其投入使用，但首先我们将解释一些相关概念，解答以下问题：

• 什么是深度学习？

• 什么是神经网络，它是如何学习的？

• 深度学习模型是如何学习的？

• 为什么选择 AutoKeras？

• 安装 AutoKeras

• Hello MNIST：实现我们的第一个 AutoKeras 实验

技术要求

本书中的所有编码示例都可以作为 Jupyter Notebook 下载，下载地址为：github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。

Jupyter Notebook 提供了一个基于 Python 的环境，可以将代码开发成一系列的步骤，称为单元格。该笔记本还提供了灵活性，可以通过在单元格中执行基于 Linux 的命令来即时安装库/依赖项。

所以，为了运行本章中的编码示例，你只需要一台安装了 Jupyter 的计算机。例如，在 Ubuntu/Linux 中，你可以使用以下命令安装：

$ apt-get install python3-pip jupyter-notebook

上一个命令将安装 Jupyter Notebook 包及其所有依赖项。

你还可以查看在 Ubuntu Linux 工作站上安装 AutoKeras部分，了解更多详细信息。

另外，你也可以使用 Google Colaboratory 运行这些笔记本，在这种情况下，你只需要一个网页浏览器。更多详情请见在 Google Colaboratory 上使用 AutoKeras部分。

什么是深度学习？

深度学习（DL）是机器学习（ML）的一种子类别，通过实现一系列层来从数据中提取模式，这些层负责提取相关特征。这些模式通过称为神经网络的机器学习模型进行学习（灵感来源于我们的大脑神经元），并按层叠加的方式组织在一起。那么，什么是层呢？层是一组称为单元的节点，它们通过处理输入并生成输出来执行操作。这种操作可以是无状态的，但通常它会有一个状态，这个状态保存在一个浮动数值数组中，称为权重。

让我们来看一个多层深度神经网络识别单个数字图像，如下所示：

图 2.1 – 用于数字分类的神经网络层的视觉表示

我们可以把网络看作是一个有多个过滤器的漏斗，其中每一层相当于一个过滤器，逐步减少杂质，直到获得期望的结果。

深度学习在许多领域有着广泛的应用，如计算机视觉、自然语言处理（NLP）、信号处理等，因此本书中解释的技术可以应用于解决多个学科中的问题。

现在我们来简要解释一下神经网络以及学习是如何进行的。

什么是神经网络，它是如何学习的？

正如我们之前所说，神经网络是由一系列相互连接的层组成的。每一层包含一组节点，每个节点都有一个相关的权重。神经网络的学习就是通过适当地修改这些权重，使得模型能够做出准确的预测。在下面的图中，我们可以看到一个简单的两层网络：

图 2.2 – 两层神经网络的视觉表示

前面图中的每一个圆圈都是一个人工神经元，它不过是受生物神经元工作方式启发的数学函数。这些人工神经元是人工神经网络中的基本单元，其工作原理是接收一个或多个输入（数值），并将其乘以一个因子或权重，然后将结果相加生成输出值。

这些模型虽然简单，但非常强大，因为它们可以通过一组已定义输入和输出的数据，学习预测我们不知道输出的新数据。例如，如果我们用一系列输入变量（如面积、位置等）训练神经网络来预测房价，网络就能够根据这些变量预测新房屋的价格。

介绍了深度学习模型的主要概念后，接下来让我们看看这些模型是如何学习的。

深度学习模型是如何学习的？

让我们来看一个多层深度神经网络识别单个数字图像，如下所示：

图 2.3 – 用于数字分类的神经网络层内容渲染

如前面的图所示，网络从数字图像中提取模式。在每一层中，它获得不同的表示，因此每一层专注于图像的某些特征，为识别其所属类别提供了必要的线索。

这基本上是深度学习（DL），一种从数据中学习模式的多阶段技术。它基于一个非常简单的概念，但通过调整它并将其扩展到足够高的水平，你可以做出惊人的预测。

现在让我们来看看为什么 AutoKeras 是我们首选的自动化机器学习（AutoML）工具。

为什么选择 AutoKeras？

正如我们在前一章所解释的，AutoKeras 是一个开源的 AutoML 框架，允许非机器学习专家以简单的方式创建高性能模型。虽然有类似的工具具有相同的目标，但 AutoKeras 专注于深度学习（DL）。虽然它不是唯一的解决方案，还有许多可用的 AutoML 服务，但大多数是云计算平台（例如亚马逊、谷歌、国际商业机器公司（IBM）），并且有一些显著的缺点，下面将详细说明：

• 机器学习云平台价格昂贵；通常你会有一个带免费额度的试用期，但如果你想定期使用它们，就需要每月支付账单。

• 根据云平台的不同，其中一些平台配置和扩展较为困难，有时需要你具备容器和集群的知识。

• 它们通常提供简单易用，但灵活性较差的现成解决方案。

由于 AutoKeras 基于开源模型，它解决了这些问题，因为你可以查看源代码、安装它并在本地免费运行。

AutoKeras 基于以下四个主要特性，简化了安装和使用：

• 它有一个基于 Keras API 的清晰直观的应用程序编程接口（API）。没有编程经验的用户也能轻松学习如何使用它，但它也允许高级用户调整较低级的系统参数。

• 它可以在本地和云端都能工作。

• 它基于动态配置，根据本地系统中可用的图形处理单元（GPU）内存调整神经网络架构的大小。

• 它由开源社区积极开发和维护。

让我们通过一个实际例子，使用 AutoKeras 创建一个简单的分类器来预测手写数字。但首先，我们需要配置一个工作环境，并在其上安装 AutoKeras 及其必要的依赖项。

如何运行 AutoKeras 实验？

作为本书中实现所有编码示例的主要工具，我们将使用 Jupyter notebook。

注意

笔记本是由 Jupyter Notebook（jupyter.org）生成的文件，Jupyter Notebook 是一个开源框架，用于创建和共享集成实时代码、可视化和富文本的文档。编辑和执行都在网页浏览器中进行，添加代码片段（称为单元格）和富文本，清晰直观地展示我们正在编写的内容。每个代码单元格都可以独立运行，使开发过程更具互动性，避免了在出现错误时必须运行所有代码。

在以下截图中，你可以看到如何通过点击工具栏上的 运行 按钮，在网页浏览器中运行我们的实验（notebook 文件）：

图 2.4 – 仅运行训练单元的 Jupyter notebook，在 AutoKeras 实验中

使用 Jupyter notebook 是开始使用 AutoKeras 的好方法，但不是唯一的方法；你还可以创建独立的 Python 脚本并通过命令行或你自己的 集成开发环境 (IDE) 运行它们。

安装 AutoKeras

在接下来的章节中，我们将详细解释安装 AutoKeras 的不同选项，以及如何一步一步配置每个选项。

安装 AutoKeras 时有两个选项：我们可以将其安装在本地工作站，或者将其安装在云端。我们将在本章中分析这两种选择的优缺点。

在云端安装 AutoKeras

在云端，我们选择了两种方案：将其安装在 亚马逊 Web 服务 (AWS) 实例/容器中，或者使用 Google Colaboratory。在这两种情况下，我们将通过网页浏览器的 Jupyter notebook 连接到云实例，正如以下截图所示。我们只需要一台可以联网的计算机来运行这些 notebook：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_02_05.jpg)

图 2.5 – AutoKeras 云端配置

让我们更详细地了解云端的选项。

使用 Google Colaboratory 的 AutoKeras

Google 提供了一项名为 Colaboratory 的 Jupyter notebook 托管服务，你可以上传自己的 Jupyter notebook，并在 Google 的云服务器上运行它们，利用 Google 硬件（GPU 或 张量处理单元 (TPU)) 的计算能力，无论你的工作站性能如何。你只需要一个网页浏览器。正如我们之前所说，notebook 可以安装其自身的依赖项，因此在运行 notebook 时可以完成 AutoKeras 的安装（就像我们在本书中的 notebook 操作一样）。

你只需按照以下三个步骤，即可运行我们的 MNIST notebook：

1. 在 colab.research.google.com 创建一个帐户。

2. 在 Colaboratory 中，通过此链接打开 GitHub 上的实验：colab.research.google.com/github/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter02/Chapter2.ipynb。

3. 点击 运行 按钮以开始安装 AutoKeras 并运行实验。

   在以下截图中，你可以看到 Colaboratory 正在运行我们的实验：

图 2.6 – 在 Google Colaboratory 中运行的 AutoKeras

所以，Google Colaboratory 是一个非常好的选择，可以快速轻松地探索和运行你的笔记本，但接下来，我们也将详细解释如何安装 Jupyter 笔记本，以及必要的依赖项，以便在 AWS 实例或你自己的工作站中运行我们的笔记本。

AWS 中的 AutoKeras

基本上，我们需要确保创建一个支持 GPU 的 Amazon EC2 Ubuntu/Linux 实例，并且安装了计算统一设备架构（CUDA）库。因为 AutoKeras 将在我们的 Jupyter 笔记本运行时安装，所以我们只需安装 Jupyter 框架并在其中运行笔记本。以下截图展示了在 AWS 实例中安装 AutoKeras 的客户端和服务器端：

图 2.7 – AutoKeras 在 AWS 实例中运行

AWS 有许多实例，其中一些已经预装了 CUDA 和 Jupyter 库，并且其端口已映射，可以从浏览器访问。它们的配置超出了本书的范围，但在docs.aws.amazon.com/dlami/上有关于如何设置 DL Amazon Machine Images（AMIs）的详细信息，这些映像允许你在 Amazon Linux 或 Ubuntu 上快速构建带有最流行 DL 框架的 Amazon Elastic Compute Cloud（EC2）实例。

如果你更喜欢使用容器而不是实例，你也可以选择运行AWS DL Containers（AWS DL Containers），这是一种类似于之前 AMIs 的 Docker 镜像，预装了 DL 软件。了解更多信息，请访问aws.amazon.com/machine-learning/containers/。

云中的 AutoKeras：优缺点

如果你没有强大的 GPU，云计算是一个很好的且廉价的选择，可以在不购买额外硬件的情况下入门。

云服务使得开始使用 AutoKeras 变得容易；你可以从头开始在 AWS 实例中设置它，将你的实验上传到像 Google Colaboratory 这样的云服务(colab.research.google.com)，或者使用 AutoKeras 扩展在远程服务器上运行训练。在书的结尾，我们将看到一个叫做 TensorFlow Cloud 的扩展，它可以让你只需插入几行代码，就能在Google Cloud Platform（GCP）上运行你的程序，轻松利用这个云平台的计算能力。

但对于更密集的 DL 使用，这种配置从长远来看并不是最合适的选择。云实例或服务是昂贵的，如果你需要训练一个模型超过几个小时，投资一台配备一个或多个 GPU 的本地工作站是值得的。

另一方面，如果你需要大规模的按需配置，建立自己的服务器集群需要高昂的人力和硬件资源成本，且比云计算替代方案更难扩展和维护。

在这张截图中，你可以看到云端与本地之间的主要差异：

图 2.8 – 云端与本地的 AutoKeras 成本比较

简而言之，在云端运行 AutoKeras 是一个非常好的起步方式。你可以按照本书中的代码示例，利用 Google Colaboratory 等云工具的强大功能，获得前沿的预测结果，但如果你计划运行自己的实验，并进行几天甚至几周的训练，最好还是购买自己的 GPU。

在本地安装 AutoKeras

如果你已经拥有自己的硬件资源，现在是时候安装软件来运行你的模型了。接下来的选项将指导你完成这一过程。

选择操作系统

当选择操作系统来运行 AutoKeras 时，Linux 无疑是最适合你的工作站和云端的选择。

虽然可以在 Windows 中使用 AutoKeras，但不推荐这样做。

更具体地说，理想的选择是 Ubuntu Linux 机器，因为它有丰富的包可供使用，并且是机器学习社区最常用的系统。如果你使用 Windows，最简单快速的解决方案是通过双启动安装 Ubuntu，按照此链接中的说明操作：help.ubuntu.com/community/WindowsDualBoot。

你还可以使用 AutoKeras 的 Docker 镜像，但根据你的硬件配置，这有时会导致无法访问 GPU 的问题。

在 Ubuntu Linux 工作站上安装 AutoKeras

一旦你在工作站上安装了 Ubuntu，你可以按照以下步骤安装 AutoKeras 并运行本书附带的笔记本文件：

1. 打开终端并运行这些命令来安装 Jupyter 笔记本：

   $ apt-get install python3-pip jupyter-notebook
   

2. 运行此命令启动笔记本：

   $ jupyter-notebook
   

3. 现在，在浏览器中访问http://127.0.0.1:8888并打开笔记本文件。

4. 在顶部菜单中，选择Runtime -> Run All来运行实验。AutoKeras 及其依赖项将在运行其余代码之前安装。

   重要提示

   GPU 设置（可选）：如果你在工作站上有 GPU，并且希望 AutoKeras 使用它们加速训练，你可以按照此教程进行设置：

   www.tensorflow.org/install/gpu

请记住，AutoKeras 仍在不断发展中，并且变化很快，安装过程可能会有所调整。因此，我建议你查看最新的安装说明，网址是autokeras.com/install/。

通过 Docker 容器运行 AutoKeras。开始使用 TensorFlow 和 Keras 的最简单方式是通过 Docker 容器运行。

Docker 是一套工具，允许你以名为容器的软件包形式安装软件，利用操作系统级的虚拟化。每个容器表现得像一个独立的操作系统，拥有自己的软件、库和配置文件，并且这些容器彼此隔离。创建 Docker 容器的过程包括三个步骤，如下所示：

1. 首先，在名为 Dockerfile 的文件中定义一个 Docker 容器。

2. 然后，使用 Docker 命令行工具，你可以从这个 Dockerfile 构建一个镜像。

3. 最后，你可以从这个镜像启动 Docker 容器。

你可以在以下图示中看到这三个步骤：

图 2.9 – 从 Dockerfile 构建容器

Docker 镜像有一个公共的存储库，叫做 Docker Hub（hub.docker.com/）。在这里，你可以找到成千上万的预安装软件包的 Docker 镜像。

你可以使用 AutoKeras 的 Docker 镜像，其中已安装最新版本的框架及其依赖项，步骤如下：

1. 按如下方式将最新的 AutoKeras Docker 镜像下载到你的机器上：

   $ docker pull haifengjin/autokeras:latest
   

2. 按如下方式运行 AutoKeras Docker 容器：

    $ docker run -it --shm-size 2G  haifengjin /autokeras /bin/bash.
   

   如果你需要更多内存，只需更改 shm-size 的值。

3. 按如下方式在容器内运行本地 Python 脚本：

$ docker run -it -v hostDir:/app --shm-size 2G  haifengjin /autokeras python file.py. 

请注意，我们已经挂载了 hostDir:/app 主机文件夹，该文件夹中包含要执行的 Python 文件。

你也可以安装 Jupyter notebook 并从 notebook 实验中运行 AutoKeras 安装过程，正如我们在前一节中所做的那样。

Hello MNIST：实现我们的第一个 AutoKeras 实验

我们的第一个实验将是使用 MNIST 数据集的图像分类器。这个 MNIST 分类任务就像是深度学习的 "hello world"。它是一个经典的将手写数字图像分类为 10 类（0 到 9）的任务。这些图像来自 MNIST，它是机器学习中最著名且被广泛使用的数据集。它包含了 70,000 张图像（其中 60,000 张用于训练，10,000 张用于测试），这些图像是 1980 年代由 NIST 收集的。

在下一张截图中，你可以看到 MNIST 数据集中每个数字的一些样本：

图 2.10 – MNIST 数据集样本图像

AutoKeras 旨在轻松分类各种类型的数据输入——例如结构化数据、文本或图像——因为每种数据都包含一个特定的类别。

对于这个任务，我们将使用 ImageClassifier。这个类会生成并测试不同的模型和超参数，返回一个最优分类器，用于分类手写数字图像。

现在，让我们详细查看 notebook 中最相关的单元格。

导入所需的包

按如下方式加载 AutoKeras 和所需的包，比如 matplotlib：

import autokeras as ak
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist

前面提到的包中包括了一个绘图库，我们已使用它来绘制一些数字表示，所使用的数据集是 MNIST 手写数字数据集。

获取 MNIST 数据集

我们首先需要将 MNIST 数据加载到内存中，并快速查看数据集的形状。为此，我们运行以下代码：

(x_train, y_train), (x_test, y_test) = mnist.load_data()
print(x_train.shape)
print(x_test.shape)

以下输出将会显示：

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
(60000, 28, 28)
(10000, 28, 28)

从前面的输出中，我们可以看到每个数据集包含28x28像素大小的图像。

现在，让我们通过运行以下代码来看看一个数字长什么样：

%matplotlib inline
fig = plt.figure()
ax = fig.add_subplot(1, 2, 1)
plt.imshow(x_train[1234])
ax.set_title('Train sample')
ax = fig.add_subplot(1, 2, 2)
plt.imshow(x_test[1234])
ax.set_title('Test sample')
plt.show()

以下输出将会显示：

图 2.11 – 训练和测试样本可视化

一旦我们查看了数据集的一些样本，就可以看看它们的分布情况。

数字是如何分布的？

当我们处理数据集时，非常重要的一点是检查数据是否均匀分布。通过使用numpy函数可以轻松完成这项工作，如以下代码块所示：

train_histogram = np.histogram(y_train)
test_histogram = np.histogram(y_test)
_, axs = plt.subplots(1, 2)
axs[0].set_xticks(range(10))
axs[0].bar(range(10), train_histogram[0])
axs[1].set_xticks(range(10))
axs[1].bar(range(10), test_histogram[0])
plt.show()

以下输出将会显示：

图 2.12 – 训练和测试数据集直方图

数据似乎是均匀分布的——每组数字的样本数量相似，因此现在是时候创建我们的模型了。

创建图像分类器

我们现在将使用 AutoKeras 的ImageClassifier类来找到最佳的分类模型。仅仅为了这个小例子，我们将max_trials（最大尝试的不同 Keras 模型数量）设置为 1，并将训练每个模型的 epoch 数量设置为 20，但对于实际使用，建议设置较大的尝试次数，并且不要设置epochs参数，以便自动使用自适应的 epoch 数量。代码如下所示：

clf = ak.ImageClassifier(max_trials=1)

让我们运行训练，寻找适合 MNIST 训练数据集的最佳分类器，步骤如下：

clf.fit(x_train, y_train, epochs=10)

以下输出将会显示：

图 2.13 – 图像分类器训练的笔记本输出

在前面的输出中，我们可以看到模型在几分钟内就达到了相当不错的训练数据集准确率。我们还可以看到最佳生成的模型已保存到磁盘。

我们还可以看到精度在每个epoch中增加，因此如果我们增加epoch的数量，模型会更精确，尽管也会花费更长时间完成。还需要注意的是，在经过大量的 epoch 后，模型通常会停止学习。

让我们使用测试数据集进行测试，以了解预测的实际准确率。

使用测试集评估模型

训练完成后，是时候使用保留的测试数据集来测量模型的实际预测结果。通过这种方式，我们可以排除训练集上获得的良好结果是由于过拟合导致的。看看以下代码片段：

metrics = clf.evaluate(x_test, y_test)
print(metrics)

以下输出将会显示：

313/313 [==============================] - 1s 4ms/step - loss: 0.0354 - accuracy: 0.9889
[0.03537507727742195, 0.9889000058174133]

我们可以看到，使用我们的测试数据集，预测准确率非常高（98.8%），考虑到我们在训练阶段只花了几分钟时间。

让我们来看看它是如何预测单个测试样本的。首先，我们可视化数字及其真实值，如下所示：

plt.imshow(x_test[1234])
plt.title('Test sample of number: %s' % y_test[1234])
plt.show()

以下输出将被显示：

图 2.14 – 待预测的测试样本

现在，我们使用我们的分类器打印预测值，如下所示：

print(clf.predict(x_test[1234, None]))

以下输出将被显示：

[['8']]

我们可以看到，输出与真实值匹配，因此我们的分类器预测是正确的。现在，让我们深入了解分类器，理解它是如何工作的。

可视化模型

我们现在将我们的分类器模型导出到 Keras，这样我们可以看到一些摘要信息，包括找到的最佳生成模型的架构。以下是我们需要做的代码：

model = clf.export_model()
model.summary()

以下输出将被显示：

图 2.15 – 图像分类模型架构总结

如果你没有 Keras 或 Tensorflow 的经验，输出可能会有些令人困惑，但别担心——要使用 AutoKeras 并不需要理解这些细节，因为工具会做所有的工作，将我们从这些细节中抽象出来。不过，了解它是如何工作的总是有益的。在后续章节中，我们将详细了解每一层的含义，但现在让我们先看看这里发生了什么。

每一层执行对输入数据的变换操作，将变换后的数据传递给下一层。

第一层有一个 28x28 的输入，对应图像的像素，如下所示的代码片段：

input_1 (InputLayer)         [(None, 28, 28)]        0       

以下树状层对图像进行变换和归一化，以适应卷积操作（Conv2D）的输入：

tf_op_layer_Cast (TensorFlow (None, 28, 28)          0      
____________________________________________________________
tf_op_layer_ExpandDims (Tens (None, 28, 28, 1)       0      
_____________________________________________________________
normalization (Normalization (None, 28, 28, 1)       3       

卷积操作层广泛应用于图像分类，它通过使用滤波器提取图像的特征（我们将在后面的章节中讨论这一点）。我们可以在以下片段中看到这个过程：

conv2d (Conv2D)              (None, 26, 26, 32)      320     
_____________________________________________________________
conv2d_1 (Conv2D)            (None, 24, 24, 64)      18496   
_____________________________________________________________
max_pooling2d (MaxPooling2D) (None, 12, 12, 64)      0       

随后，出现了多个层，防止过拟合，通过执行 dropout（随机断开部分神经连接），具体如下：

dropout (Dropout)            (None, 12, 12, 64)      0      
____________________________________________________________
flatten (Flatten)            (None, 9216)            0       
____________________________________________________________
dropout_1 (Dropout)          (None, 9216)            0       

然后，执行全连接操作，将卷积操作的输出维度缩减为 10 个元素，这些元素对应从 0 到 9 的数字，具体如下：

dense (Dense)                (None, 10)              92170   

最后一层（Softmax）只保留 10 个元素中最高的值，这个值将对应最终预测的数字，具体如下：

classification_head_1 (Softm (None, 10)              0  

有一种更具图形化的方式来可视化模型，让我们通过运行以下代码来查看：

from tensorflow.keras.utils import plot_model
plot_model(clf.export_model())

以下输出将被显示：

![图 2.16 – 图像分类模型架构可视化]

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_02_16.jpg)

图 2.16 – 图像分类模型架构可视化

在上述图中，每个块代表一个层，每个层的输出连接到下一个层的输入，除了第一个块（其输入是图像）和最后一个块（其输出是预测值）。

创建图像回归器

现在，我们将使用不同的方法来从图像中找出数字值：一个称为回归器的回归模型。

图像回归器将尝试预测数字的标量值，而不是将其分类为 0-9 类别。

AutoKeras 已经有一个准备好使用的特殊类称为 ImageRegressor，它将找到最佳的回归模型。

就像我们对分类器所做的那样，对于这个小例子，我们将 max_trials（尝试的不同 Keras 模型的最大数量）设置为 1，并将每个模型训练的时期数设置为 20，但是对于实际使用，建议设置一个较大的试验数，并且不设置 epochs 参数以自动使用自适应数量的 epochs。

首先，我们初始化图像回归器，如下所示：

reg = ak.ImageRegressor(
overwrite=True,
max_trials=1)

现在，使用训练数据集来喂养图像回归器，如下所示。

reg.fit(x_train, y_train, epochs=20)

现在是真相的时刻——让我们用我们的测试集来评估它。

使用测试集评估模型

最后，我们使用以下代码评估最佳模型与测试数据集：

reg.evaluate(x_test, y_test)

将显示以下输出：

图 2.17 – 图像回归器训练的笔记本输出

在 20 分钟后，找到的最佳模型具有 0.083 的值，这并不差。均方误差（MSE）是衡量回归模型性能的广泛使用的度量标准。

让我们使用找到的最佳模型预测测试数据集的前 10 个数字，并打印预测值和真实值以进行比较。我们可以通过运行以下代码来实现：

predicted_y = reg.predict(x_test[:10])
print(list(y_test[:10]))
print([round(float(i)) for i in predicted_y])

将显示以下输出：

[7, 2, 1, 0, 4, 1, 4, 8, 5, 9]
[7, 2, 1, 0, 4, 1, 4, 8, 5, 9]

正如您所看到的，它在每一个案例中都预测了真实值。让我们通过运行以下代码以更加图形化地看待它：

fig = plt.figure()
for i, v in enumerate(predicted_y):
    ax = fig.add_subplot(2, 5, i+1)
    ax.set_axis_off()
    ax.set_title(round(float(v)))
    plt.imshow(x_test[i])
plt.show()

将显示以下输出：

图 2.18 – 图像数字标签与预测值

请注意，我们已经将回归器返回的浮点值四舍五入以与真实值进行比较。这是因为回归器总是返回接近实际值的连续值，所以如果我们想要预测离散值（0 到 9 的数字），我们必须进行四舍五入以返回预测值。

现在，就像我们对分类器所做的那样，让我们来看看生成的最佳模型的架构。

可视化模型

我们将模型导出为 Keras 模型，然后调用 model.summary 函数来查看架构，如下所示：

model = clf.export_model()
model.summary()

将显示以下输出：

图 2.19 – 图像回归模型架构摘要

就像我们对分类器所做的那样，有一种更加直观的方式来看待它，如下所示：

from tensorflow.keras.utils import plot_model
plot_model(clf.export_model())

以下输出将会显示：

图 2.20 – 图像回归模型架构可视化

在这个分类器的示例中，我们简要展示了每个模块的概况。我们不会在这里深入讲解，因为我认为这对于“入门”章节已经足够。在接下来的章节中，我们将更详细地解释截图中出现的每个模块。

总结

在本章中，你已经学习了如何使用 AutoKeras 的主要选项，从安装到在不同环境中的运行。

你也已经看到了 AutoKeras 的强大功能，通过仅用几行代码和 2 分钟的训练，成功实现了两种高精度图像分类器的方法。

现在你已经学会了从头实现一个深度学习模型，只需要按照相同的步骤并简单地更换数据集，你的模型就能够分类各种图像。

在接下来的章节中，你将学习如何解决与图像、结构化数据和纯文本等输入数据源相关的更复杂任务。但在此之前，在下一章，我们将介绍如何使用一些有趣的工具来准备数据，以尽可能自动化地将其输入到 AutoKeras。

第三章：第三章：使用 AutoKeras 自动化机器学习管道

自动化机器学习管道涉及自动化一系列过程，如数据探索、数据预处理、特征工程、算法选择、模型训练和超参数调整。

本章将解释标准机器学习管道以及如何使用AutoKeras自动化其中的一些步骤。我们还将描述训练模型之前需要应用的主要数据准备最佳实践。数据准备后的步骤由 AutoKeras 执行，我们将在后面的章节中深入了解这些步骤。

正如我们在第一章中看到的，AutoKeras 可以通过应用超参数优化和神经架构搜索（NAS）来自动化所有管道建模步骤，但在这些步骤之前，某些数据预处理仍需手动完成或使用其他工具。

我们将解释模型所期望的数据表示形式，以及 AutoKeras 应用的基本预处理技术。在本章结束时，您将学到适合且最佳的方式来为模型提供数据的主要格式和技术。

本章将涵盖以下主要主题：

• 理解张量

• 为深度学习模型准备数据

• 以多种格式将数据加载到 AutoKeras 中

• 将数据集分割用于训练和评估

在本章中，我们将介绍一些基本的预处理技术，以及如何使用 AutoKeras 助手来应用它们，但首先，让我们解释一下模型所期望的数据结构是什么以及它们是如何表示的。

理解张量

在 MNIST 示例中，数字图像被存储在 NumPy 矩阵中，也叫张量。这些张量是机器学习模型的基本数据结构。现在我们已经知道了模型所需的输入，让我们更深入地了解张量是什么以及它们的不同类型。

什么是张量？

张量基本上是一个多维数组，通常是 N 维的浮动点数（也叫做轴）。

张量由三个关键属性定义：轴的数量或秩、每个轴的维度或形状，以及它包含的数据类型。让我们详细解释一下：

• numpy命名法（ndim）。例如，标量（单个数字）没有轴，向量（数字列表）有一个，矩阵（向量列表）有两个，而 3D 张量（矩阵列表）有三个。我们来看一个实际的例子：

  >>> import numpy as np 
  >>> x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) 
  >>> x.ndim
  2
  

  在前面的代码片段中，我们创建了一个矩阵并打印了它的秩（2）。

• 形状（每个轴的维度）：这是每个轴的维度，并返回一个元组，包含相应数组维度的长度。对于矩阵，第一个项对应行数，第二个项对应列数，如以下代码所示：

  >>> import numpy as np 
  >>> x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) 
  >>> x.shape 
  (4, 3) 
  

  这一次，我们创建了一个矩阵并打印了它的形状（4 行，3 列）。

• 数据类型：张量中包含的数据类型通常是浮点数，因为计算机在处理这种数据时更加高效。例如，在以下矩阵中，存储的项目是整数：

  >>> import numpy as np 
  >>> x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) 
  >>> x.dtype 
  dtype('int64')Here we have created a matrix and printed the type of its items (int64)
  

现在我们已经解释了张量的关键属性，接下来看看我们可以使用哪些类型的张量。

张量的类型

根据它们的维度，我们可以将张量分类如下：

• 标量（N=0）：只包含一个数字的张量被称为标量；让我们创建一个：

  >>> import numpy as np 
  >>> t = np.array(123) 
  >>> t 
  array(123) 
  >>> v.ndim 
  0
  

  通过创建一个标量并打印它的阶数，我们可以看到它的值是 0。

• 向量（N=1）：1D 张量被称为向量。它是一个一维的数字数组，如下代码所示：

  >>> x = np.array([1, 2, 3]) 
  >>> xarray([1, 2, 3]) 
  >>> x.ndim 
  1
  

  在这里，我们创建了一个 1 维的向量并打印了它的阶数。

• [1, 2, 3] 和第一列是 [1, 4, 7]，分别表示。

• 3D 张量（N=3）：3D 张量是矩阵的数组。这个张量通常用来表示图像，使用 3 个矩阵数组，其中每个矩阵代表像素的一个颜色（红色、绿色或蓝色）。你可以将它想象为一个充满数字的立方体。让我们用以下代码创建一个：

  >>> x = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]]) 
   >>> x.ndim 
   3
  

  在这里，我们可以看到，对于 3D 张量返回的阶数是 3。

• 4D 张量（N=4）：4D 张量是 3D 张量的数组。这种复杂结构常用于存储视频，视频基本上是一批帧，每一帧是由 3D 张量表示的图像。

以下是这些阶数的视觉表示：

图 3.1 – 不同阶数的张量视觉表示

3D 张量可以存储 RGB 图像或帧，而 4D 张量可以将视频作为一组帧的数组来存储。

为深度学习模型准备数据

在上一章中，我们解释了 AutoKeras 是一个专门用于深度学习的框架，使用神经网络作为学习引擎。我们还学会了如何为 MNIST 手写数字数据集创建端到端的分类/回归模型。该数据集已经过预处理，可以供模型使用，这意味着所有图像都有相同的属性（相同的大小、颜色等），但情况并非总是如此。

一旦我们知道了什么是张量，就可以开始学习如何输入我们的神经网络。大多数数据预处理技术是特定领域的，我们将在需要在特定示例中使用时在后续章节中解释它们。但首先，我们将介绍一些基础知识，这些知识是每个具体技术的基础。

神经网络模型的数据预处理操作

在本节中，我们将讨论一些可以用来将原始输入数据转换为更合适格式的操作。这将使我们能够将数据输入神经网络，从而提高模型的学习性能。

主要的数据预处理操作包括特征工程、数据归一化、数据向量化和缺失值处理。让我们详细了解一下：

• 特征工程：这是从原始数据中提取特征的过程，利用领域专家的知识，这些提取的特征能够改善我们模型的性能。

  在传统的机器学习中，特征工程至关重要，但在深度学习中，这个过程的重要性不那么突出，因为神经网络能够自动从原始输入数据中提取相关特征。然而，在某些情况下，特征工程仍然至关重要，例如当我们没有足够大的数据集、输入数据是结构化的，或者资源有限时。在这些情况下，这一步对于实现我们的目标至关重要。

• 数据归一化：神经网络在处理小的输入值时效果更好，通常在 0 到 1 之间。因为学习算法是基于梯度更新权重参数的方式进行的，所以小的数值会导致更快的更新，从而加速训练过程，而较大的数值则会减慢训练过程。通常，数据集包含较大的数值，因此在将它们输入到模型之前，我们需要将它们缩放到 0 到 1 的范围内。这种技术叫做归一化。AutoKeras 已经为我们完成了这一过程。在前面的数字分类示例中，数据集包含了从 0 到 255 的整数编码图像。然而，我们将数据喂入模型时并未执行归一化，因为 AutoKeras 已经自动为我们处理了这个问题。

• 前一章中展示的MINST示例，数据集已经被向量化，因此这个过程并不必要。

• 缺失值处理：数据集通常在某些记录中包含缺失值。那么您的模型应该如何处理这些不完整的记录呢？通常，对于深度学习模型，将缺失值初始化为 0 是一种常见做法，只要 0 不是一个重要的数值。一旦神经网络模型学会了 0 代表缺失值，它就会在每次遇到时忽略它。需要注意的是，如果您的模型将在现实世界中接触到缺失值，而您在训练时没有考虑到它们，它将无法学会忽略这些缺失值。因此，在这种情况下，一个常见的做法是人工生成缺失值，强迫您的模型学习如何处理它们。

现在我们已经了解了主要的数据结构及其transform操作，接下来我们将探讨 AutoKeras 支持的数据格式以及它如何将原始数据转换为更适合的格式。

将数据以多种格式加载到 AutoKeras 中

如前所述，AutoKeras 会自动执行归一化。然而，在接下来的章节中，您将看到通过堆叠模块，您可以以更个性化的方式创建模型。更具体地说，您可以使用特定的模块来归一化数据。

现在，让我们看看可以用来为模型提供输入的不同数据结构。

AutoKeras 模型接受三种类型的输入：

• NumPy 数组是Scikit-Learn和许多其他基于 Python 的库常用的数组类型。只要数据能适应内存，这是最快的选择。

• Python 生成器将数据批次从磁盘加载到内存，因此当整个数据集无法适应内存时，这是一个不错的选择。

• TensorFlow Dataset是一种高性能选项，类似于 Python 生成器，但更适合深度学习和大规模数据集。这是因为数据可以从磁盘或分布式文件系统中流式传输。

在将数据提供给 AutoKeras 模型之前，你可以将数据准备为以下格式之一。如果你使用大规模数据集并且需要在 GPU 上训练，最佳选择是使用TensorFlow Dataset对象，因为它们在性能和灵活性方面有许多优势，例如：

• 它可以执行异步预处理和数据排队。

• 它提供了 GPU 内存数据预加载功能，因此在 GPU 完成处理前一个批次之后，数据将立即可用。

• 它提供了转换原语，让你可以对数据集中的每个元素应用一个函数，从而生成一个新的转换后的数据集。

• 一个缓存，保持已从数据集读取的最新批次数据在内存中。

• 你可以从多个来源加载数据（NumPy 数组、Python 生成器、CSV 文件、文本文件、文件夹等等）。

以下图示表示所有可以使用 TensorFlow Dataset 对象作为输入的数据源类型：

图 3.2 – TensorFlow Dataset 对象输入源的可视化表示

AutoKeras 提供了非常有用的工具，帮助你将磁盘上的原始数据转换为 TensorFlow Dataset：

• autokeras.image_dataset_from_directory将以特定方式存储在目录中的图像文件转换为带标签的图像张量数据集。让我们学习如何处理图像目录。

  以下目录结构合理，这意味着我们可以将其提供给 AutoKeras。每个类别的图像都有一个子文件夹：

  main_directory/
  ...class_a/
  ......a_image_1.jpg
  ......a_image_2.jpg
  ...class_b/
  ......b_image_1.jpg
  ......b_image_2.jpg
  

  现在，我们必须将此文件夹路径传递给autokeras函数，以便从图像目录创建数据集：

  autokeras.image_dataset_from_directory(
      main_directory,
      batch_size=32,
      color_mode="rgb",
      image_size=(256, 256),
      interpolation="bilinear",
      shuffle=True,
      seed=None,
      validation_split=None,
      subset=None,
  )
  

  有几个参数，但只有路径目录（main_directory）是必需的；其余的参数默认设置。我们将在后续章节中详细解释它们。

• autokeras.text_dataset_from_directory从以特定方式存储在目录中的文本文件生成 TensorFlow Dataset。正如我们之前看到的图像一样，我们必须为每个类别创建一个子文件夹：

  # Directory structure
  main_directory/
  ...class_a/
  ......a_text_1.txt
  ......a_text_2.txt
  ...class_b/
  ......b_text_1.txt
  ......b_text_2.txt
  # Create a dataset from the texts directory
  autokeras.text_dataset_from_directory(directory, batch_size=32, max_length=None, shuffle=True, seed=None, validation_split=None, subset=None)
  

  如前所述，处理图像时，只需要路径目录（directory）；其他参数如果没有初始化，将会默认设置。我们将在后面的章节中更详细地解释这些内容。

此外，AutoKeras 可以通过直接将文件名作为参数传递给其结构化数据模型来处理 CSV 文件；也就是说，autokeras.StructuredDataClassifier 和 autokeras.StructuredDataRegressor。现在我们已经知道哪些数据类型最适合 AutoKeras 以及它为数据预处理提供了哪些工具，接下来我们将学习如何划分数据集，以便正确地评估和测试模型。

拆分你的数据集以进行训练和评估

要评估一个模型，你必须将数据集分为三个子集：训练集、验证集和测试集。在训练阶段，AutoKeras 会使用训练数据集来训练模型，同时使用验证数据集来评估模型的性能。一旦准备好，最终的评估将使用测试数据集进行。

为什么你应该拆分数据集

拥有一个在训练过程中不被使用的独立测试数据集对于避免信息泄漏非常重要。

如前所述，验证集用于根据模型的表现来调整模型的超参数，但一些关于验证数据的信息会被过滤到模型中。因此，你可能会面临一个模型在验证数据上表现得非常好，因为它是为此训练的。然而，模型的实际表现应基于我们使用之前未见过的数据，而不是验证数据，所以我们必须使用一个不同且全新的数据集来评估模型。这就是所谓的测试数据集。

为了避免信息泄漏，确保模型从未接触过测试集的任何信息，甚至是间接的，这一点非常重要。这就是为什么拥有一个独立的测试数据集如此重要的原因。

如何拆分数据集

在上一章的 MNIST 示例中，我们没有明确拆分数据集，因为 load_data 方法为我们完成了拆分。然而，通常这些数据集只是一个记录集，你需要自行拆分。以下是数据集拆分的可视化表示：

图 3.3 – 数据集拆分的可视化表示

当 AutoKeras 在训练模型时，默认会将 20% 的训练集保留用于验证，但你始终可以通过在 fit 函数中使用 validation_split param 来定义不同的百分比。在以下代码中，我们使用这个参数将训练数据拆分，并使用最后 15% 作为验证数据：

reg.fit(x_train, y_train,validation_split=0.15)  

我们也可以手动创建验证数据集并将其作为 validation_data param: split = 5000 传递：

x_val = x_train[split:] 
y_val = y_train[split:] 
x_train = x_train[:split] 
y_train = y_train[:split] 
reg.fit(x_train, 
        y_train, 
        epochs=2, 
        validation_data=(x_val, y_val))

你也可以使用 train_test_split 函数来进行拆分：

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, ...) 

现在，让我们总结一下本章所学的内容。

概述

在这一章，我们学习了张量，它是网络的主要数据结构；一些神经网络的数据预处理操作；AutoKeras 支持的数据格式，以及它的数据预处理工具。最后，我们还学习了如何快速简便地划分数据集。现在，你已经准备好以最合适的方式为你的 AutoKeras 模型提供动力。

在下一章，我们将学习如何使用 AutoKeras 处理图像。我们还将介绍一些技术，教你如何从图像中提取特定特征，并应用这些技术。

第二部分：AutoKeras 实践

本节着重介绍书中提供的许多代码示例，为你提供如何使用 AutoKeras 自动化深度学习解决现实问题的实践见解。

本节包含以下章节：

• 第四章**，使用 AutoKeras 进行图像分类和回归

• 第五章**，使用 AutoKeras 进行文本分类和回归

• 第六章**，使用 AutoKeras 处理结构化数据

• 第七章**，使用 AutoKeras 进行情感分析

• 第八章**，使用 AutoKeras 进行主题分类

第四章：第四章：使用 AutoKeras 进行图像分类与回归

本章我们将重点介绍 AutoKeras 在图像上的应用。在第二章中，入门 AutoKeras，我们首次接触了应用于图像的深度学习（DL），通过创建两个模型（一个分类器和一个回归器），实现了对手写数字的识别。我们现在将创建更复杂、更强大的图像识别器，分析它们的工作原理，并学习如何微调它们以提高性能。

阅读完本章后，你将能够创建自己的图像模型，并将其应用于解决现实世界中的各种问题。

正如我们在第二章中讨论的那样，入门 AutoKeras，最适合图像识别的模型使用一种叫做卷积神经网络（CNN）的神经网络类型。对于我们在本章中看到的两个例子，AutoKeras 也会选择 CNN 来创建其模型。所以，让我们更详细地了解这些类型的神经网络是什么，以及它们是如何工作的。

本章将涉及以下主要主题：

• 理解 CNN——这些神经网络是什么，它们是如何工作的？

• 创建一个 CIFAR-10 图像分类器

• 创建和微调一个强大的图像分类器

• 创建一个图像回归器以找出人的年龄

• 创建和微调一个强大的图像回归器

技术要求

本书中的所有编码示例都可以作为 Jupyter Notebooks 下载，链接如下：github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。

由于代码单元可以执行，每个笔记本都可以通过添加所需的代码片段进行自我安装。因此，在每个笔记本的开头都有一个环境设置的代码单元，用于安装 AutoKeras 及其依赖项。

因此，要运行编码示例，你只需要一台操作系统为 Ubuntu/Linux 的计算机，并且可以通过以下命令行安装 Jupyter Notebook：

$ apt-get install python3-pip jupyter-notebook

另外，你也可以通过 Google Colaboratory 运行这些笔记本，在这种情况下，你只需要一个网页浏览器——有关更多详情，请参见第二章中关于AutoKeras 与 Google Colaboratory的部分，入门 AutoKeras。此外，在安装 AutoKeras部分，你还可以找到其他安装选项。让我们通过详细了解 CNN 来开始。

理解 CNN

CNN 是一种神经网络，灵感来源于生物大脑视觉皮层中神经元的工作原理。

这类网络在解决计算机视觉问题（如图像分类、物体检测、分割等）方面表现非常出色。

以下屏幕截图显示了 CNN 如何识别猫：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_04_01.jpg)

图 4.1 – CNN 如何识别猫

但为什么这些 CNN 比传统的全连接模型更有效呢？为了解答这个问题，让我们深入探讨卷积层和池化层的作用。

卷积层

CNN 的关键构建块是卷积层，它使用一个窗口（卷积核）扫描图像，并对其进行变换以检测模式。

核心不过是一个简单的神经网络，由扫描窗口的像素矩阵提供输入，输出一个数字向量，我们将使用这些向量作为滤波器。

让我们想象一个卷积层，其中有许多小的方形模板（称为卷积核），它们穿过图像并寻找模式。当输入图像的某个区域与卷积核模式匹配时，卷积核返回一个正值；否则，它返回 0 或更小的值。

以下屏幕截图显示了卷积层如何处理图像：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_04_01.jpg)

图 4.2 – 卷积层如何处理图像

一旦我们获得了滤波器，我们就必须使用池化操作来减少它们的维度，下一步将会解释这一过程。

池化层

池化层的功能是逐步减小输入特征矩阵的大小，从而减少网络中的参数数量和计算量。最常见的池化方式是最大池化，它通过对输入特征矩阵的非重叠子区域应用最大值滤波器来执行下采样。

以下屏幕截图提供了最大池化的示例：

图 4.3 – 最大池化示例

在前面的屏幕截图中，我们可以看到一个特征矩阵上进行最大池化操作的例子。对于图像来说，这个矩阵将由图像的像素值组成。

应用这一操作可以通过减少需要处理的特征数量，从而降低计算成本，同时有助于防止过拟合。接下来，我们将看到卷积层和池化层在 CNN 中是如何结合的。

CNN 结构

通常，CNN 由一系列卷积层组成，之后是池化层（下采样）。这一组合会重复多次，正如我们在下面的屏幕截图示例中看到的那样：

图 4.4 – CNN 管道示例

在这个过程中，第一层检测简单的特征，比如图像的轮廓，第二层开始检测更高层次的特征。在中间层，它已经能够检测到更复杂的形状，比如鼻子或眼睛。在最后几层，它通常能够区分人脸。

这个看似简单的重复过程非常强大，每一步都能检测出比前一步稍高阶的特征，并生成惊人的预测结果。

超越经典神经网络

经典神经网络使用全连接（密集）层作为主要的特征转换操作，而 CNN 则使用卷积层和池化层（Conv2D）。

完全连接层和卷积层之间的主要区别如下：

• 完全连接层学习其输入特征空间的全局模式（例如，在修改后的国家标准与技术研究所（MNIST）数据集的数字示例中，见第二章，AutoKeras 入门，输入特征空间将是图像的所有像素）。

• 另一方面，卷积层学习局部模式——在图像的情况下，是通过小的二维窗口扫描图像时发现的模式。

在下面的截图中，我们可以看到这些小窗口如何检测局部模式，如线条、边缘等：

图 4.5 – 卷积网络提取模式的可视化表示

卷积操作通过一个扫描输入图像的窗口（2D 矩阵）来执行图像转换，生成一张具有不同特征的新图像。每一张生成的图像称为滤波器，每个滤波器包含从原始图像中提取的不同模式（如边缘、轴线、直线等）。

CNN 中每个中间层创建的滤波器集合被称为特征图，它是一个具有r x c x n维度的数字矩阵，其中r和c分别是行和列，n是滤波器的数量。

基本上，这些特征图是 CNN 学习的参数。

如我们在查看第二章，AutoKeras 入门中的 MNIST 分类器架构时所见，CNN 堆叠了多个卷积层（Conv2D），并结合池化层（MaxPooling2D）。后者的任务是减少滤波器的维度，保留最相关的值。这有助于清除噪声并减少模型的训练时间。

现在，是时候实现一些实际示例了。让我们从一个著名数据集的图像分类器开始。

创建一个 CIFAR-10 图像分类器

我们将要创建的模型将对一个名为32x32的红色、绿色、蓝色（RGB）彩色图像数据集进行分类，分为 10 个不同类别。它是一个常用于训练机器学习和计算机视觉算法的图像集合。

这是数据集中的各个类别：

• airplane

• automobile

• bird

• cat

• deer

• dog

• frog

• horse

• ship

• truck

在下一张截图中，你可以看到 CIFAR-10 数据集中一些随机的图像样本：

图 4.6 – CIFAR-10 图像样本

这是一个已经被认为解决了的问题。实现接近 80%的分类准确率相对容易。为了获得更好的性能，我们必须使用深度学习 CNN，通过它可以在测试数据集中实现超过 90%的分类精度。让我们看看如何使用 AutoKeras 实现这一点。

这是一个分类任务，因此我们可以使用ImageClassifier类。该类生成并测试不同的模型和超参数，返回一个最佳分类器，将每个图像分类到相应的类别。

注意

完整源代码的笔记本可以在github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter04/Chapter4_Cifar10.ipynb找到。

现在让我们详细查看一下笔记本中的相关单元格，如下所示：

• pip 包管理器：

  !pip3 install autokeras
  

• matplotlib，我们将使用它来绘制一些数字表示图，并且 CIFAR-10 包含已分类的图像数据集。以下是导入这些包的代码：

  import autokeras as ak
  import matplotlib.pyplot as plt
  from tensorflow.keras.datasets import cifar10
  

• 获取 CIFAR-10 数据集：我们首先需要将 CIFAR-10 数据集加载到内存中，并快速查看数据集的形状，如下所示：

  (x_train, y_train), (x_test, y_test) = cifar10.load_data()
  print(x_train.shape)
  print(x_test.shape)
  

  以下是前面代码的输出：

  Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
  170500096/170498071 [==============================] - 11s 0us/step
  (50000, 32, 32, 3)
  (10000, 32, 32, 3)
  

尽管这是一个广为人知的机器学习数据集，但始终确保数据分布均匀非常重要，以避免出现意外情况。可以通过使用numpy函数轻松实现这一点，如下代码块所示：

import numpy as np 
train_histogram = np.histogram(y_train)
test_histogram = np.histogram(y_test)
_, axs = plt.subplots(1, 2)
axs[0].set_xticks(range(10))
axs[0].bar(range(10), train_histogram[0])
axs[1].set_xticks(range(10))
axs[1].bar(range(10), test_histogram[0])
plt.show()

如下截图所示，样本完美平衡：

图 4.7 – 训练和测试数据集直方图

现在我们确认我们的数据集是正确的，接下来是创建我们的图像分类器。

创建并微调一个强大的图像分类器

现在，我们将使用 AutoKeras 的ImageClassifier类来找到最佳的分类模型。仅此示例，我们将max_trials（尝试的不同 Keras 模型的最大数量）设置为2，并且不设置epochs参数，以便它自动使用自适应的训练轮数。对于实际使用，建议设置更多的尝试次数。代码如下：

clf = ak.ImageClassifier(max_trials=2)

让我们运行训练，搜索 CIFAR-10 训练数据集的最佳分类器，如下所示：

clf.fit(x_train, y_train)

这是输出结果：

图 4.8 – 图像分类器训练的笔记本输出

前面的输出显示，训练数据集的准确率正在上升。

由于需要处理成千上万的彩色图像，AutoKeras 生成的模型在训练时会更为昂贵，因此这个过程将需要几个小时，即使使用max_trials = 5。增加这个数字将给我们一个更准确的模型，尽管它也会花费更长的时间才能完成。

提升模型性能

如果我们需要在更短时间内获得更高精度，我们可以使用 AutoKeras 的高级功能来微调我们的模型，允许你自定义搜索空间。

通过使用AutoModel与ImageBlock代替ImageClassifier，我们可以创建高级配置，例如用于指定神经网络类型的block_type。我们还可以执行数据标准化或数据增强。

如果我们有深度学习的知识，并且之前遇到过这个问题，我们可以设计一个合适的架构，例如基于EfficientNet的图像分类器，它是用于图像识别的深度残差学习架构。

请查看以下示例，了解更多细节：

input_node = ak.ImageInput()
output_node = ak.ImageBlock(
             block_type="efficient",
             augment=False)(input_node)
output_node = ak.ClassificationHead()(output_node)
clf = ak.AutoModel(inputs=input_node, outputs=output_node, max_trials=2)
clf.fit(x_train, y_train)

在前面的代码块中，我们已经使用以下设置完成了操作：

• 使用block_type = "efficient"，AutoKeras 将只探索EfficientNet架构。

• 初始化augment = True表示我们希望进行数据增强，这是一种通过原始图像生成新的人工图像的技术。在激活此功能后，AutoKeras 将对原始图像执行一系列变换，如平移、缩放、旋转或翻转。

你也可以不指定这些参数，在这种情况下，这些不同的选项会被自动调整。

你可以在这里看到关于EfficientNet函数的更多细节：

• keras.io/api/applications/efficientnet/

• keras.io/api/applications/resnet/

使用测试集评估模型

训练完成后，接下来就是使用保留的测试数据集来衡量模型的实际预测效果。通过这种方式，我们可以将从训练集获得的良好结果与从未见过的数据集进行对比。为此，我们运行以下代码：

metrics = clf.evaluate(x_test, y_test)
print(metrics)

这是输出结果：

313/313 [==============================] - 34s 104ms/step - loss: 0.5260 - accuracy: 0.8445
[0.525996744632721, 0.8445000052452087]

我们可以看到，使用我们的测试数据集（84.4%）预测准确率仍有提升空间，尽管这是仅仅几个小时训练得到的相当不错的得分；但通过增加尝试次数，我们已经实现了首个模型（ImageClassifier）的 98%精度，并且在 Google Colaboratory 中运行了一整天。

一旦我们创建并训练了分类器模型，让我们看看它在一部分测试样本上的预测结果。为此，我们运行以下代码：

import matplotlib.pyplot as plt
labelNames = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
fig = plt.figure(figsize=[18,6])
for i in range(len(predicted_y)):
    ax = fig.add_subplot(2, 5, i+1)
    ax.set_axis_off()
    ax.set_title('Prediced: %s, Real: %s' % (labelNames[int(predicted_y[i])],labelNames[int(y_test[i])]))
    img = x_test[i]
    ax.imshow(img)
plt.show()

这是输出结果：

图 4.9 – 带有预测标签和真实标签的样本

我们可以看到，所有预测的样本都与其真实值匹配，因此我们的分类器预测正确。现在，让我们深入了解分类器，理解它是如何工作的。

可视化模型

现在，我们可以看到一个小的总结，展示了最佳生成模型的架构（即准确度为 98%的模型），我们将解释它为什么能有如此好的表现。运行以下代码查看总结：

model = clf.export_model()
model.summary()

这是输出：

图 4.10 – 最佳模型架构总结

这里的关键层是efficientnetb7层，它实现了由 Google 创建的前沿架构。如今，EfficientNet 模型是图像分类的最佳选择，因为这是一个最近的架构，不仅专注于提高准确度，还关注模型的效率，使其在现有的卷积网络架构基础上实现更高的精度和更好的效率，减少参数大小和每秒浮动点操作数（FLOPS）数量级。然而，我们不需要了解任何关于它的内容，因为 AutoKeras 已经自动为我们选择了它。

让我们以一种更直观的方式来看一下各个块是如何相互连接的，如下所示：

图 4.11 – 最佳模型架构可视化

正如我们在 第二章《AutoKeras 入门》中解释的那样，每个块表示一个层，每个块的输出连接到下一个块的输入，除了第一个块（其输入是图像）和最后一个块（其输出是预测结果）。在efficientnetb7层之前的所有块都是数据预处理块，负责将图像转换为适合此EfficientNet块的格式，并通过数据增强技术生成额外的图像。

现在是处理非分类问题的时候了。在接下来的实际示例中，我们将基于一组名人数据创建一个人类年龄预测器——一个有趣的工具，可能会让任何人脸红。

创建一个图像回归器来预测人们的年龄

在本节中，我们将创建一个模型，该模型能够从人脸图像中找出一个人的年龄。为此，我们将使用从互联网电影数据库（IMDb）提取的名人面孔数据集来训练该模型。

由于我们要预测年龄，我们将使用图像回归器来完成这项任务。

在下一张截图中，你可以看到一些从这个名人面孔数据集中提取的样本：

图 4.12 – 来自 IMDb 面孔数据集的几个图像样本

这本包含完整源代码的笔记本可以在这里找到：github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter04/Chapter4_CelebrityAgeDetector.ipynb。

接下来，我们将详细解释笔记本中的相关代码单元，具体如下：

• pip包管理器。代码如下所示：

  !pip3 install autokeras
  

• 导入所需的包：现在我们加载 AutoKeras 和一些常用的包，如 matplotlib，一个 Python 绘图库，我们将使用它来绘制一些图片样本和类别分布。执行此操作的代码如下所示：

  import autokeras as ak
  import matplotlib.pyplot as plt
  

• 获取 IMDb 面部数据集：在训练之前，我们必须下载包含每个人脸图像及带有年龄标签的元数据的 IMDb 裁剪面部数据集。

  以下命令行是幂等的—它们只会在数据不存在时下载并解压数据：

  !wget -nc https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/static/imdb_crop.tar
  !tar --no-overwrite-dir -xf imdb_crop.tar
  

  这是前面代码的输出：

  Resolving data.vision.ee.ethz.ch (data.vision.ee.ethz.ch)... 129.132.52.162
  Connecting to data.vision.ee.ethz.ch (data.vision.ee.ethz.ch)|129.132.52.162|:443... connected.
  HTTP request sent, awaiting response... 200 OK
  Length: 7012157440 (6.5G) [application/x-tar]
  Saving to: 'imdb_crop.tar'
  imdb_crop.tar       100%[===================>]   6.53G  27.7MB/s    in 3m 59s  
  2020-12-20 00:05:48 (28.0 MB/s) - 'imdb_crop.tar' saved [7012157440/7012157440]
  

• MatLab文件。

  b. 年龄不在参数中—它必须被计算出来。

  c. 图像不一致—它们的尺寸和颜色不同。

  为了解决这些问题，我们创建了以下的工具函数：

  a. imdb_meta_to_df(matlab_filename)：此函数将 IMDb MatLab 文件转换为 Pandas DataFrame，并计算年龄。

  b. normalize_dataset(df_train_set)：这会返回一个元组，包含归一化后的图像（调整为128x128并转换为灰度）和转为整数的年龄。

在笔记本中，你将找到更多关于这些函数如何工作的细节。

现在让我们来看一下如何使用它们，具体如下：

df = imdb_meta_to_df("imdb_crop/imdb.mat")

在前面的代码片段中，我们使用了imdb_meta_to_df函数，将存储在 MatLab 文件中的imdb元数据信息转换为 Pandas DataFrame。

DataFrame 包含了大量的图像；为了加速训练，我们将只使用其中一部分图像来创建数据集，具体如下：

train_set = df.sample(10000)
test_set = df.sample(1000)

现在，我们创建最终的数据集，包含归一化的图像和年龄，具体如下：

train_imgs, train_ages = normalize_dataset(train_set)
test_imgs, test_ages = normalize_dataset(test_set)

一旦所有图片的尺寸（128×128）和颜色（灰度图）一致，并且我们有了标签和估计的年龄，我们就可以准备输入模型，但首先我们需要创建它。

创建和微调一个强大的图像回归器

因为我们要预测年龄，并且这是一个标量值，所以我们将使用 AutoKeras 的ImageRegressor作为年龄预测器。我们将max_trials（尝试的不同 Keras 模型的最大数量）设置为10，并且不设置epochs参数，这样它会自动使用适应性数量的 epochs。对于实际使用，建议设置较大的试验次数。代码如下所示：

reg = ak.ImageRegressor(max_trials=10)

让我们运行训练模型，寻找适合训练数据集的最佳回归器，具体如下：

reg.fit(train_imgs, train_ages)

这是前面代码的输出：

图 4.13 – 我们的年龄预测器训练的笔记本输出

前面的输出显示训练数据集的损失正在下降。

这个训练过程在 Colaboratory 中花费了 1 小时。我们将搜索限制为 10 种架构（max_trials = 10），并将图像数量限制为 10,000。增加这些数字将给我们一个更精确的模型，尽管也会花费更多时间。

提升模型性能

如果我们需要在更短的时间内获得更高的精度，我们可以使用 AutoKeras 的高级功能微调我们的模型，从而自定义搜索空间。

正如我们在回归模型示例中所做的那样，我们可以使用 AutoModel 配合 ImageBlock，而不是使用 ImageRegressor，这样我们就可以实现更高级的配置，比如使用 block_type 搜索特定架构的神经网络。我们还可以执行数据预处理操作，比如归一化或增强。

正如我们在之前的图像分类器示例中所做的那样，我们可以设计一个合适的架构，例如基于 EfficientNet 的图像回归器，这是一种用于图像识别的深度残差学习架构。

请参见以下示例以获取更多细节：

input_node = ak.ImageInput()
output_node = ak.Normalization()(input_node)
output_node = ak.ImageAugmentation()(output_node)
output_node = ak.ImageBlock(block_type="efficient")(input_node)
output_node = ak.RegressionHead()(output_node)
reg = ak.AutoModel(inputs=input_node, outputs=output_node, max_trials=20)
reg.fit(train_imgs, train_ages)

在之前的代码中，我们已经做了以下设置：

• Normalization 块会将所有图像值从 0 到 255 的范围转换为 0 到 1 之间的浮动值。

• 已经设置了形状（60000, 28 * 28），值在 0 和 1 之间。

• 使用 ImageBlock(block_type="efficient"，我们告诉 AutoKeras 只扫描 EfficientNet 架构。

• ImageAugmentation 块执行数据增强，这是通过原始图像生成新的人工图像的一种技术。

你也可以选择不指定这些参数，在这种情况下，系统将自动调整这些不同的选项。

你可以在这里查看更多关于 EfficientNet 函数的细节：

keras.io/api/applications/efficientnet/

使用测试集评估模型

训练后，是时候使用保留的测试数据集来衡量我们模型的实际预测效果了。这样，我们可以排除训练集获得的好结果是由于过拟合造成的。执行此操作的代码如下：

print(reg.evaluate(test_imgs, test_ages))

这是前面代码的输出：

32/32 [==============================] - 2s 51ms/step - loss: 165.3358 - mean_squared_error: 165.3358
[165.33575439453125, 165.33575439453125]

这个错误还有很大的提升空间，但让我们看看它是如何在一部分测试样本上进行预测的，如下所示：

fig = plt.figure(figsize=[20,100])
for i, v in enumerate(predicted_y[0:80]):
    ax = fig.add_subplot(20, 5, i+1)
    ax.set_axis_off()
    ax.set_title('Prediced: %s, Real: %s' % (predicted_y[i][0], test_ages[i]))
    img = test_imgs[i]
    ax.imshow(img)
plt.show()

这是前面代码的输出：

图 4.14 – 样本及其预测标签与真实标签

我们可以看到一些预测样本接近真实年龄，但另一些则不然，因此投入更多的训练时间和微调将使其预测得更好。让我们深入了解分类器，理解它是如何工作的。

可视化模型

现在我们可以看到通过运行以下代码找到的最佳生成模型的架构简要总结：

model = clf.export_model()
model.summary()

这是前面代码的输出：

图 4.15 – 最佳模型架构概览

这里的关键层是卷积和池化块，正如我们在本章开头所解释的那样。这些层从图像中学习局部模式，帮助进行预测。以下是这一点的可视化表示：

图 4.16 – 最佳模型架构可视化

首先，有一些数据预处理块用于规范化图像并进行数据增强；然后，接下来是几个堆叠的卷积和池化块；接着是一个 dropout 块用于正则化（这是一种减少过拟合的技术，通过在训练过程中随机丢弃神经元，减少相邻神经元之间的相关性）；最后，我们看到回归块，它将输出转换为一个标量（即年龄）。

概览

在本章中，我们学习了卷积网络的工作原理，如何实现图像分类器，以及如何微调它以提高准确性。我们还学习了如何实现图像回归器并微调它以提高性能。

现在我们已经学会了如何处理图像，我们准备进入下一章，您将在那里学习如何通过使用 AutoKeras 实现分类和回归模型来处理文本。

第五章：第五章：使用 AutoKeras 进行文本分类和回归

在本章中，我们将重点介绍使用 AutoKeras 处理文本（即一系列单词）的方式。

在上一章中，我们看到有一种专门适用于图像处理的网络类型，叫做卷积神经网络（CNN）。在本章中，我们将了解什么是递归神经网络（RNN），以及它们如何工作。RNN 是一种非常适合处理文本的神经网络类型。

我们还将使用分类器和回归器来解决基于文本的任务。到本章结束时，你将学会如何使用 AutoKeras 解决各种基于文本的问题，例如从推文中提取情绪、检测电子邮件中的垃圾邮件等。

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

• 处理文本数据

• 理解 RNN——这些神经网络是什么，它们如何工作？

• 一维 CNN（Conv1D）

• 创建电子邮件垃圾邮件检测器

• 预测社交媒体新闻的流行度

技术要求

本书中的所有代码示例都可以作为 Jupyter 笔记本下载，下载链接如下：github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。

由于代码单元格可以执行，每个笔记本都可以自我安装，只需添加包含所需依赖项的代码片段。因此，在每个笔记本的开始部分都有一个代码单元格用于环境设置，安装 AutoKeras 及其依赖项。

因此，要运行这些代码示例，你只需要一台操作系统为 Ubuntu Linux 的计算机，并且可以使用以下命令行安装 Jupyter Notebook：

$ apt-get install python3-pip jupyter-notebook

另外，你也可以使用 Google Colaboratory 运行这些笔记本，这时只需要一个网页浏览器。有关详细信息，请参见 第二章 中的 AutoKeras 与 Google Colaboratory 部分，AutoKeras 入门。此外，在 安装 AutoKeras 部分，你还会找到其他安装选项。

处理文本数据

AutoKeras 使我们能够快速轻松地创建高性能模型来解决基于文本的任务。

文本是喂养深度学习模型的优秀信息来源，存在大量基于文本的资源，例如社交媒体、聊天记录、电子邮件、文章、书籍，以及无数需要基于文本自动化的任务，如下所示：

• 翻译：将一种语言的源文本转换为另一种语言的文本。

• 对话机器人：使用机器学习模型模拟人类对话。

• 情感分析：通过分析文本数据来分类情绪。

• 垃圾邮件分类器：使用机器学习模型进行电子邮件分类。

• 文档摘要生成器：自动生成文档摘要。

• 文本生成器：从零开始自动生成文本。

与其他类型的数据一样，AutoKeras 会完成所有的预处理工作，这样我们就可以直接将文本传递给模型。在开始实际示例之前，让我们先看看它在幕后做了什么。

标记化

如我们所知，神经网络输入的是数值向量，因此文本必须通过一个叫做向量化的过程转换为数值张量。不过，在这之前，我们必须先将文本切分成片段。

这种文本分割可以通过以下不同的单位来完成：

• 单词：将文本按单词进行划分。

• 字符：将文本切分成字符。

• N-gram：提取词或字符的 N-gram。N-gram 是多个连续词或字符的重叠分组。

前面提到的单位称为标记，将文本划分为这些标记的过程称为标记化。这是将文本转换为张量的必要步骤，接下来我们将解释这一过程。

向量化

一旦文本被标记化，就会进行向量化。这个过程将每个单词/字符/N-gram 转换为一个向量。

所有文本向量化过程包括以下步骤：

1. 应用某种标记化方案

2. 将数值向量与生成的标记关联

这些向量被打包成序列张量，输入到深度神经网络（DNNs）中。

有多种方式可以将标记与向量关联。让我们来看两种最重要的方式，如下所示：

• 1 和向量中的所有其他值都是零。

• 标记嵌入是另一种广泛使用的标记-向量关联方式，且比 One-hot 编码更为强大。虽然 One-hot 编码得到的向量是二进制的（一个输入值为1，其余值为0），且长度很大（必须与词汇表中单词的数量相同），而词嵌入则是低维的浮点向量。

  通过 One-hot 编码得到的词向量是静态的（数组中的位置决定了单词，这些值永远不会改变），而词嵌入向量是动态的（它们是从数据中学习得到的），以至于它们的值在学习过程中会发生变化，就像神经网络层的权重一样。

  正是这种动态性使它能够以更小的尺寸存储更多信息，正如你在以下截图中看到的那样：

图 5.1 – One-hot 编码与嵌入比较

就像卷积网络是处理基于图像任务的最合适选择一样，在谈到文本处理时，最优化的网络类型是 RNN。让我们在接下来的部分看看它的组成。

理解 RNN

到目前为止，所有神经网络的共同特点是它们没有记忆。由全连接层或卷积层组成的网络独立地处理每个输入，使得每一层都是孤立的。然而，在 RNN 中，“过去”会被考虑进去，这通过使用上一个输出作为状态来完成；因此，RNN 层将有两个输入，一个是当前向量的标准输入，另一个是前一个向量的输出，如下图所示：

图 5.2 – RNN 循环展开

RNN 通过对整个元素序列的内部循环来实现这个记忆特性。我们用一些伪代码来解释，如下所示：

state = 0
for input in input_sequence:
     output = f(input, state)
     state = output

虽然有许多比本书所展示的更复杂的 RNN 架构，但这超出了本书的范围。理解这里解释的概念就足够了，因为配置和架构的选择将由 AutoKeras 来处理。

一维卷积神经网络（Conv1D）

处理文本时需要考虑的另一种架构是一维卷积神经网络（Conv1D）。它们的原理与我们在上一章中看到的二维卷积神经网络类似，参见 第四章，使用 AutoKeras 的图像分类与回归。这些神经网络通过滤波器学习文本中的模式，就像它们在上一章中学习图像模式一样。

以下是一个一维卷积神经网络的示例：

图 5.3 – 1D 卷积在文本序列上的应用

需要知道的是，如果序列中元素的时间顺序对于预测很重要，那么 RNN 的效果会更好，因此一维卷积神经网络常常与 RNN 结合使用，以创建高性能模型。AutoKeras 进行的全面搜索会同时考虑这两者，以找到最佳模型。

现在，让我们通过一些实际例子来实践所学的概念。

创建电子邮件垃圾邮件检测器

我们将创建的模型将从 emails 数据集中检测垃圾邮件。这是一个包含 5,572 封邮件的小型数据集，带有 spam 列标签。

包含完整源代码的笔记本可以通过以下链接找到：

colab.research.google.com/github/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter05/Chapter5_SpamDetector.ipynb

现在让我们详细查看笔记本中的相关单元格，具体如下：

• pip 包管理器：

  !pip3 install autokeras
  

• tensorflow、pandas、numpy 和 autokeras 作为此项目所需的依赖项：

  import tensorflow as tf
  import pandas as pd 
  import numpy as np
  import autokeras as ak
  from sklearn import model_selection
  

• 来自我们 GitHub 仓库的 emails 垃圾邮件数据集，详见如下：

  emails_dataset = pd.read_csv("https://raw.githubusercontent.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/main/spam.csv", encoding="latin-1")
  

  我们现在通过重命名相关列并删除不必要的列来准备我们的数据集，如下所示：

  emails_dataset.drop(['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'], axis = 1, inplace = True)
  emails_dataset.rename(columns = {'v1': 'spam', 'v2': 'message'}, inplace = True)
  emails_dataset['spam'] = emails_dataset['spam'].map({'ham': 0, 'spam': 1})
  emails_dataset.head()
  

  这是前面代码的输出：

图 5.4 – 数据集预览的笔记本输出

现在，让我们将数据集拆分为train和test数据集，如下所示：

x_train, x_test, y_train, y_test = model_selection.train_test_split(emails_dataset.message.to_numpy(), emails_dataset.spam.to_numpy())

我们已准备好创建垃圾邮件分类器。

创建垃圾邮件预测器

现在，我们将使用 AutoKeras 的TextClassifier类来找到最佳的分类模型。仅为了这个小示例，我们将max_trials（尝试的最大不同 Keras 模型数量）设置为 2，并且不设置epochs参数，而是定义了一个EarlyStopping回调，当验证损失在连续两个 epoch 内没有改善时，训练过程就会停止。代码如下所示：

clf = ak.TextClassifier(max_trials=2)
cbs = [tf.keras.callbacks.EarlyStopping(patience=2)]

让我们开始训练，以寻找训练数据集的最佳分类器，如下所示：

clf.fit(x_train, y_train, callbacks=cbs)

这是前面代码的输出：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_05_05.jpg)

图 5.5 – 文本分类器训练的笔记本输出

上面的输出显示，使用训练数据集时，准确率在不断提高。

如我们所见，在验证集上我们达到了0.080的损失值。仅仅经过一分钟的训练，结果已经非常好。我们将搜索范围限制在两种架构内（max_trials = 2）。增加该数字会使模型更准确，但也会增加训练时间。

评估模型

现在是时候使用测试数据集评估最佳模型了。我们可以通过运行以下命令来实现：

clf.evaluate(x_test, y_test)

这是前面命令的输出：

44/44 [==============================] - 0s 4ms/step - loss: 0.0491 - accuracy: 0.9849
[0.04908078908920288, 0.9849246144294739]

如我们所见，0.9849的测试集预测准确率是非常好的最终预测得分，考虑到投入的时间，这个结果非常令人满意。

可视化模型

现在，我们可以看到最佳生成模型的架构的简要总结。我们可以通过运行以下代码来实现：

model = clf.export_model()
model.summary()

这是前面代码的输出：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_05_06.jpg)

图 5.6 – 最佳模型架构总结

如我们所见，AutoKeras 选择了卷积模型（Conv1D）来完成这个任务。正如我们在第四章《使用 AutoKeras 进行图像分类与回归》中解释的那样，这种架构在序列中元素的顺序对预测结果不重要时效果非常好，正如本例所示。

下面是架构的可视化表示：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_05_07.jpg)

图 5.7 – 最佳模型架构可视化

正如你们所知，生成模型并选择最佳模型是 AutoKeras 自动完成的任务，但让我们简要解释一下这些模块。

每个块代表一层，且每层的输出连接到下一层的输入，除了第一个块（其输入是文本）和最后一个块（其输出是预测的数字）。Conv1D 块之前的所有块都是数据预处理块，用于将文本生成的嵌入向量化以馈送到 Conv1D 块，并通过最大池化层降低过滤器的维度。请注意，AutoKeras 还添加了多个 dropout 块以减少过拟合。

在下一节中，我们将通过一个实际示例来解决文本回归问题：我们将创建一个新闻流行度预测器。

在社交媒体上预测新闻的流行度

在这一部分，我们将创建一个模型，基于文章的文本来预测其在社交媒体平台上的流行度评分。为此，我们将使用 2015 至 2016 年间收集的新闻流行度数据集来训练模型（archive.ics.uci.edu/ml/datasets/News+Popularity+in+Multiple+Social+Media+Platforms）。

由于我们希望预测一个分数（点赞数），因此我们将使用文本回归器来完成这项任务。

在下一个截图中，您可以看到从该数据集中提取的一些样本：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_05_08.jpg)

图 5.8 – 来自新闻流行度数据集的几个样本

这个包含完整源代码的笔记本可以在colab.research.google.com/github/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter05/Chapter5_SpamDetector.ipynb找到。

我们现在将详细解释笔记本中的相关代码单元，如下所示：

• 获取文章数据集：在训练之前，我们必须下载包含每篇文章文本及其流行度评分的数据集。以下是实现这一目的的代码：

  news_df = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/00432/Data/News_Final.csv")
  

• Title和Headline文本列将用来馈送给我们的回归模型。

  现在，我们提取每篇文章在 LinkedIn 上的流行度评分，作为标签。为了简化示例，我们决定只使用 LinkedIn 上的评分。代码如下所示：

  media_success_outputs = news_df.LinkedIn.to_numpy(dtype="int")
  

  接下来，我们将创建训练集和测试集，如下所示：

• 使用sklearn函数创建train和test数据集，如下所示：

  from sklearn.model_selection import train_test_split
  x_train, x_test, y_train, y_test = train_test_split(text_inputs, media_success_outputs, test_size = 0.2, random_state = 10)
  

一旦我们创建了数据集，就可以将其输入模型，但首先，我们需要创建模型。

创建文本回归器

因为我们想从一组文本句子中预测一个流行度分数，而这个分数是一个标量值，所以我们将使用 AutoKeras 的TextRegressor。在这个示例中，我们将max_trials设置为2，并且没有设置epochs参数，而是定义了一个EarlyStopping回调，耐心等待2个 epoch，即如果验证损失在两个连续的 epoch 中没有减少，训练过程将停止。代码可以在以下代码片段中看到：

reg = ak.ImageRegressor(max_trials=2)
cbs = [tf.keras.callbacks.EarlyStopping(patience=2)]

让我们运行训练，搜索训练数据集的最佳回归器，如下所示：

reg.fit(x_train, y_train, callbacks=cbs)

这是前面代码的输出：

图 5.9 – 我们的新闻流行度预测器训练的笔记本输出

从之前的输出中可以看到，几分钟后，我们得到一个模型，最佳验证损失为14726（最终得分中的121是14726的平方根，对于投入的时间来说，这是一个不错的结果。接下来看看它在测试集上的表现。

评估模型

现在是时候使用测试数据集评估最佳模型了。我们通过运行以下代码来完成：

reg.evaluate(x_test, y_test)

这是前面代码的输出：

583/583 [==============================] - 3s 5ms/step - loss: 13944.2070 - mean_squared_error: 13944.2070

[13944.20703125, 13944.20703125]

如我们所见，13944是一个非常好的预测得分，考虑到投入的时间。如果我们使用更多的试验来运行 AutoKeras，我们会得到更好的结果。

可视化模型

现在，是时候看看我们引擎盖下的内容了。我们将运行以下代码：

model = reg.export_model()
model.summary()

这是前面代码的输出：

图 5.10 – 最佳模型架构摘要

如同前面的分类示例一样，AutoKeras 选择了卷积模型（Conv1D）来完成任务。正如我们之前解释的，这比 RNN 架构更节省时间，且当序列中元素的顺序对于预测并不重要时，它是最合适的。

提升模型性能

正如我们在之前的示例中所做的那样，如果我们需要更高的精度并且希望节省时间，我们可以通过使用 AutoKeras 的高级功能来微调我们的模型，允许你自定义搜索空间。

通过使用AutoModel与TextBlock代替TextRegressor，我们可以创建高级配置，例如block_type来指定要查找的神经网络类型；或者，如果你的文本源有更大的词汇表（不同词汇的数量），你可能需要在 AutoKeras 中创建一个自定义的流水线来增加max_tokens参数。

详情请见以下示例：

cbs = [tf.keras.callbacks.EarlyStopping(patience=2)]
input_node = ak.TextInput()
output_node = ak.TextToIntSequence(max_tokens=20000)(input_node)
output_node = ak.TextBlock(block_type='ngram')(input_node)
output_node = ak.RegressionHead()(output_node)
automodel = ak.AutoModel(inputs=input_node, outputs=output_node, objective='val_mean_squared_error', max_trials=2)
automodel.fit(x_train, y_train, callbacks=cbs)

在前面的代码块中，我们已经根据设置进行了以下操作：

• EarlyStopping块将在验证损失在两个连续的 epoch 中没有减少时停止训练。

• max_token参数设置为20000，因为我们的文本源有一个较大的词汇表（不同词汇的数量）。

• 使用TextBlock(block_type="ngram"时，我们告诉 AutoKeras 仅扫描使用 N-gram 嵌入的模型。

你也可以选择不指定这些参数，这样不同的选项将会自动调整。

使用测试集评估模型

训练完成后，是时候使用保留的测试数据集来测量我们模型的实际预测效果了。这样，我们可以排除训练集上获得的良好结果是由于过拟合造成的。运行以下代码来实现这一点：

automodel.evaluate(x_test, y_test)

下面是前面代码的输出：

583/583 [==============================] - 6s 9ms/step - loss: 13508.9316 - mean_squared_error: 13508.9316
[13508.931640625, 13508.931640625]

性能稍微好于没有微调的模型，但肯定通过更长时间的训练会进一步提升它。

总结

在本章中，我们学习了神经网络如何与文本数据一起工作，什么是循环神经网络以及它们如何工作。

我们还通过使用 AutoKeras 的强大功能，将神经网络的概念付诸实践，实现了一个垃圾邮件预测器和一个新闻热门度回归器，只用了几行代码。

既然我们已经学会了如何处理文本数据，我们准备进入下一章，在这一章中你将学习如何通过使用 AutoKeras 实现分类和回归模型来处理结构化数据。

第六章：第六章：使用 AutoKeras 处理结构化数据

在本章中，我们将重点介绍如何使用 AutoKeras 处理结构化数据，也称为表格数据。我们将学习如何探索这种类型的数据集，并应用哪些技术来解决基于这种数据源的问题。

完成本章后，你将能够探索一个结构化数据集，转换它，并将其作为特定模型的数据源，此外还能够创建你自己的分类和回归模型来解决基于结构化数据的任务。

本章将具体涵盖以下主题：

• 理解结构化数据

• 处理结构化数据

• 创建一个结构化数据分类器来预测泰坦尼克号生还者

• 创建一个结构化数据回归器来预测波士顿房价

技术要求

本书中的所有编码示例都可以作为 Jupyter 笔记本下载，下载地址为本书 GitHub 仓库：colab.research.google.com/github/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter06/Chapter6_HousingPricePredictor.ipynb。

由于代码单元格可以执行，每个笔记本都可以自我安装，因此你可以添加你需要的代码片段来满足需求。因此，在每个笔记本的开头，都会有一个用于环境设置的代码单元格，用于安装 AutoKeras 及其依赖项。

因此，要运行本书中的编码示例，你只需要一台操作系统为 Ubuntu Linux 的计算机，并使用以下代码安装相应的 Jupyter 笔记本：

$ apt-get install python3-pip jupyter-notebook

或者，你也可以使用 Google Colaboratory 来运行这些笔记本。在这种情况下，你只需要一个 Web 浏览器。有关更多详细信息，请参阅第二章中关于使用 Google Colaboratory 的 AutoKeras部分，开始使用 AutoKeras。此外，在该章节的安装 AutoKeras部分，你将找到其他安装选项。

理解结构化数据

结构化数据基本上就是表格数据；也就是说，由数据库中的行和列表示的数据。这些表格包含以下两种类型的结构化数据：

• 数值数据：这是在数值尺度上表示的数据。此外，它有两种表示方式，如下所示：

  a. 连续型：可以在一个区间内取任何值的数据，例如温度、速度、身高等。例如，一个人的身高可以是任何值（在人类身高范围内），而不仅仅是某些固定的身高。

  b. 离散型：只能取非可分整数值的数据，例如计数器。例子包括银行账户中的钱数、一个国家的人口等。

• 类别数据：这是只能取一组特定值的数据，通常对应可能的类别。它们又分为以下几类：

  a. 二元：只能接受两个值（0/1）的数据

  b. 有序：具有明确顺序的数据，例如一周中的每一天

需要了解每个特征的数据类型，以便应用适当的预处理方法。例如，如果 DataFrame 中的某一列包含有序数据，则必须先对其进行独热编码处理，然后才能传递给模型。

处理结构化数据

AutoKeras 允许我们快速、轻松地创建高性能的模型，以解决基于结构化数据的任务。

根据每列的格式，AutoKeras 会在输入模型之前自动进行预处理。例如，如果某列包含文本数据，它会将其转换为嵌入；如果列值是固定类别，它会将其转换为独热编码数组，等等。

在接下来的部分，我们将看到如何轻松处理表格数据集。

创建一个结构化数据分类器来预测 Titanic 幸存者

该模型将根据从 Titanic Kaggle 数据集中提取的特征，预测 Titanic 乘客是否会在船沉没时生还。尽管运气是生存的重要因素，但某些群体的生还几率更高。

该数据集中包含一个训练数据集和一个测试数据集。两个数据集都类似，包含乘客信息，如姓名、年龄、性别、社会经济阶层等。

训练数据集（train.csv）包含关于部分乘客的详细信息（准确来说是 891 名），并揭示了他们是否在survived列中生还。

测试数据集（test.csv）将用于最终评估，并包含其他 418 名乘客的类似信息。

AutoKeras 将在训练数据中寻找模式，以预测其他 418 名登船乘客（见test.csv）是否幸存。

完整的源代码笔记本可以在github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter06/Chapter6_TitanicClassifier.ipynb找到。

现在，让我们详细查看笔记本中的相关单元格：

• 安装 AutoKeras：正如我们在其他示例中提到的，笔记本顶部的这段代码负责通过 pip 包管理器安装 AutoKeras 及其依赖项：

  !pip3 install autokeras
  

• 导入必要的包：以下代码行加载了 TensorFlow、pandas 和 AutoKeras，作为该项目所需的依赖项：

  import tensorflow as tf
  import autokeras as ak
  import pandas as pd
  

• 创建数据集：首先，我们将加载 Titanic 数据集作为 pandas 数据框：

  train_file_url = "https://storage.googleapis.com/tf-datasets/titanic/train.csv"
  test_file_url = "https://storage.googleapis.com/tf-datasets/titanic/eval.csv"
  train_df = pd.read_csv(train_file_url)
  test_df = pd.read_csv(test_file_url)
  

  现在，我们必须将标签（目标）与其他乘客特征（输入）分开：

  x_train_df, y_train_df = train_df.drop(['survived'], axis=1), train_df['survived']
  

• 展示一些样本：接下来，我们将打印前几行，以查看列的值：

  train_df.head()
  

  这是前面代码的输出：

图 6.1 – 训练数据集前几行的笔记本输出

前面的截图显示了乘客信息在不同列中的表示。第一列（survived）将作为预测目标。

现在，是时候创建分类器模型了。

创建分类器

现在，我们将使用 AutoKeras 的StructuredDataClassifier来寻找最佳分类模型。仅在这个示例中，我们将max_trials（尝试的不同 Keras 模型的最大数量）设置为2，并将 epochs 参数设置为10：

clf = ak.StructuredDataClassifier(
max_trials=2, 
overwrite=True)

让我们运行训练过程，以搜索训练数据集的最佳分类器：

clf.fit(
    x_train_df,
    y_train_df,
    epochs=10,
)

StructuredDataClassifier接受不同的输入格式。你可以像我们在前面的代码中那样传入一个 pandas DataFrame，但它也接受其他格式，如 NumPy 数组和 TensorFlow 数据集。它还允许你直接传递 URL 或文件路径，模型会自动下载并加载。要使用这种选项，必须将目标列的名称作为第二个参数传递：

clf.fit(
    train_file_url,
    'survived',
    epochs=10,
)

两种情况的输出将会相似：

图 6.2 – 结构化数据分类器训练的笔记本输出

之前的输出显示训练数据集的准确率在提高。

如我们所见，我们在验证集上达到了0.84的最佳预测准确率。这是一个相当不错的数字，仅用了几秒钟的训练。我们将搜索限制为 10 个 epoch 和两种架构（max_trials = 2）。简单地增加这些数字将给我们带来更好的准确率，但也会花费更长时间来完成训练。

评估模型

让我们使用测试数据集评估最佳模型：

clf.evaluate(test_file_url, 'survived')

这是前面代码的输出：

9/9 [==============================] - 0s 2ms/step - loss: 0.4322 - accuracy: 0.8068
[0.4321742355823517, 0.8068181872367859]

如我们所见，0.80也是一个非常好的最终预测分数，考虑到我们所投入的训练时间。

可视化模型

现在我们有了一个胜出的模型，让我们来看一下它的架构摘要：

model = clf.export_model()
model.summary()

这是前面代码的输出：

图 6.3 – 最佳模型架构摘要

如我们所见，AutoKeras 已经为我们完成了所有的预处理工作，通过将类别列转换为类别并对其进行标准化。

让我们看一下这个的可视化表示：

图 6.4 – 最佳模型架构可视化

在数据预处理模块（多类别和标准化）之后，AutoKeras 选择了一个全连接神经网络。这是一个经典的机器学习架构，适用于表格数据。这是有道理的，因为结构化数据更适合用经典的机器学习模型进行训练，因为数据中的模式更加明确。

在下一节中，我们将通过预测房价来解决结构化数据回归问题。

创建一个结构化数据回归器以预测波士顿房价

在接下来的示例中，我们将尝试预测 1970 年代中期波士顿郊区的中位房价，给定该时段的郊区数据特征，如犯罪率、财产税率、当地财产等。

我们将创建一个模型，基于特征预测特定郊区的房价。为此，我们将使用boston_housing数据集来训练该模型，我们需要将其添加到我们的仓库中（github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/boston.csv）。我们将使用的数据集相对较小——包含 506 个样本，分为 404 个训练样本和 102 个测试样本。请注意，该数据集没有经过标准化，这意味着输入数据中的每个特征在其值上应用不同的尺度。例如，一些列的值范围在 0 到 1 之间，而其他的则在 1 到 12 之间、0 到 100 之间，等等。因此，这是一个很好的数据集，用于测试 AutoKeras 的自动预处理功能。

数据集的特征（列）可以总结如下：

• CRIM：按城镇分类的犯罪率（人均）

• ZN：用于 25,000 平方英尺以上地块的住宅用地比例

• INDUS：每个城镇的非零售商业用地比例

• CHAS：查尔斯河虚拟变量（若该地块界限为河流，则为 1；否则为 0）

• NOX：氮氧化物浓度（每 1000 万分之一）

• RM：每个住宅的平均房间数

• AGE：1940 年之前建造的自住单元的比例

• DIS：到波士顿五个就业中心的加权平均距离

• RAD：可达径向高速公路的可达性指数

• TAX：每$10,000 的全额财产税率

• PTRATIO：按城镇分类的师生比

• LSTAT：低收入人群的百分比

• MEDV：业主自住房屋的中位价值（以千美元为单位）

以下截图展示了该数据集的一些样本：

图 6.5 – 波士顿住房数据集的一些样本

由于我们要近似预测一个价格，因此我们将使用结构化数据回归器来完成这项任务。

本示例的笔记本及完整源代码可以在github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter06/Chapter6_HousingPricePredictor.ipynb找到。

让我们详细解释一下笔记本中的相关代码单元：

• 获取波士顿房价数据集：在训练之前，我们必须下载包含每个郊区特征的数据集，其中包括中位数价格：

   df = pd.read_csv("https://raw.githubusercontent.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/main/boston.csv")
  y = df.pop('MEDV')
  X = df
  train_data, test_data, train_targets, test_targets = train_test_split(X,y,test_size=0.2)
  

• 数据预处理：由于我们有数据集作为一个包，我们将在创建训练集和测试集时使用中位数价格列（MEDV）作为目标值。请注意，在将数据传递给模型之前，一些列会先进行预处理。AutoKeras 会自动对这些列进行预处理，对连续值进行归一化（将值设置在 0 和 1 之间），对离散值进行分类（进行独热编码）。稍后在模型架构中，我们将看到为此目的创建的数据预处理模块。

创建结构化数据回归器

因为我们想从一组特征中预测一个价格，而这个价格是一个标量值，所以我们将使用 AutoKeras 的StructuredDataRegressor，这是一个结构化数据回归类，它创建一个回归模型，接受x作为结构化数据集（如 CSV 文件名、NumPy 数组、pandas DataFrame 或 TensorFlow 数据集）以及y作为标签数据集（与输入数据集格式相同的一列数据集，或者如果输入数据来自 CSV 文件，则是目标列名称）作为输入。

在这种情况下，数据集较小，训练周期比其他示例快，因此我们将max_trials设置为 20，并将 epochs 参数设置为 50：

reg = ak.StructuredDataRegressor(
    max_trials=20,
    overwrite=True,
    metrics=['mae']
)

对于回归模型，AutoKeras 使用均方误差（MSE）作为默认损失函数。正如我们在前几章中解释的那样，这是预测值与目标值之间差异的平方。但对于这个示例，我们在训练过程中还会监控一个新的指标，这将为我们提供更多信息：平均绝对误差（MAE）。这是预测值与目标值之间差异的绝对值。例如，在这个问题中，MAE 为 1.5 意味着你的预测平均偏差为$1,500。

让我们运行训练过程，搜索最佳模型：

reg.fit(
    train_data,
    train_targets,
    epochs=50,
)

下面是前述代码的输出：

图 6.6 – 训练房价预测模型的笔记本输出

如前述输出所示，在不到 5 分钟的时间内，我们的模型的最佳验证损失（MSE）为5.05。这意味着在最终得分中，预测的平均偏差为2.24（5.05 的平方根）。这超过了$2,200。对于只有 5 分钟的训练时间来说，这并不是一个坏结果，因此让我们用测试集来评估它。

评估模型

我们准备用测试数据集评估我们的最终模型。让我们开始吧：

reg.evaluate(test_data, test_targets)

这是前述代码的输出：

4/4 [==============================] - 0s 5ms/step - loss: 13.9013 - mae: 2.4202
[13.901305198669434, 2.420168161392212]

让我们看一下我们的新指标，MAE。它的值为2.420，这意味着我们的预测平均偏差为$2,420。这是对我们投入时间的一个非常好的预测误差。如果我们运行更多的试验和周期，很可能会得到更好的结果。

模型可视化

现在，是时候看看我们底层的内容了：

keras_model = reg.export_model()
keras_model.summary()

这是前述代码的输出：

图 6.7 – 最佳模型架构总结

就像前面的分类示例一样，AutoKeras 已经为我们完成了所有的预处理工作，通过multi_category_encoding块将具有离散值的列转换为类别，并使用normalization块对连续值列进行归一化。

让我们看看它的视觉表示：

图 6.8 – 最佳模型架构可视化

在上一张图中，我们可以更加简略地看到模型的不同层次。现在，让我们总结一下本章学到的内容。

摘要

在这一章中，我们学习了什么是结构化数据及其不同的类别，如何用不同的结构化数据格式（如 pandas、CSV 文件等）来喂养我们的 AutoKeras 模型，并且学会了如何使用一些 pandas 函数加载和探索表格数据集。

最后，我们通过创建一个强大的结构化数据分类器模型来预测泰坦尼克号的幸存者，并创建一个强大的结构化数据回归模型来预测波士顿房价，应用了这些概念。

通过这些技术，您已经学会了如何使用 AutoKeras 解决基于结构化数据的任何问题。使用这些技术，任何CSV文件都可以成为您可以用来训练模型的数据集。

在下一章中，我们将学习如何使用 AutoKeras 对文本进行情感分析。

第七章：第七章：使用 AutoKeras 进行情感分析

让我们先定义标题中的不寻常术语。情感分析是文本分类中广泛使用的术语，基本上是通过使用自然语言处理（NLP）结合机器学习（ML）来解读和分类文本中的情感。

为了理解这个概念，让我们假设任务是判断一篇电影评论是正面还是负面。您自己看完评论就能做出判断，对吧？然而，如果我们的老板发给我们 1000 条电影评论让我们明天完成，那事情就复杂了。这就是情感分析变得有趣的地方。

本章将使用文本分类器从文本数据中提取情感。文本分类的大部分概念已经在第四章，使用 AutoKeras 进行图像分类和回归中解释过了，所以在本章中，我们将通过实现情感预测器以一种实际的方式来应用它们。然而，在我们开始之前，我们将首先了解开始工作所需的技术要求。

本章将具体涵盖以下主题：

• 创建情感分析器

• 创建分类器

• 评估模型

• 可视化模型

• 分析特定句子中的情感

技术要求

本书中的所有代码示例都可以作为 Jupyter notebooks 下载，您可以从github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras获取。

由于代码单元可以执行，因此每个 notebook 都可以自我安装；您只需要添加需要的依赖代码片段。因此，在每个 notebook 的开头都有一个用于环境设置的代码单元，它会安装 AutoKeras 及其依赖项。

所以，要运行本章的代码示例，您只需要一台操作系统为 Ubuntu Linux 的计算机，并用以下代码安装 Jupyter Notebook：

$ apt-get install python3-pip jupyter-notebook

或者，您也可以使用 Google Colaboratory 运行这些 notebooks，这种情况下您只需要一个网页浏览器。更多细节请参见第二章，使用 Google Colaboratory 进行 AutoKeras部分。此外，在该章的安装 AutoKeras部分，您还可以找到其他安装选项。

现在，让我们通过一些实际示例来实践我们所学的内容。

创建情感分析器

我们要创建的模型将是一个用于情感的二分类器（1=正面/0=负面），数据集来自 IMDb 情感数据集。该数据集是一个二分类情感分类数据集，包含 25,000 条带情感标签的电影评论用于训练，另有 25,000 条用于测试：

图 7.1 – 在两个样本上使用情感分析的示例

类似于第四章中的 Reuters 示例，使用 AutoKeras 进行图像分类和回归，每个评论都被编码为一个单词索引列表（整数）。为了方便起见，单词根据其在数据集中的总体频率进行索引。例如，整数 3 表示数据中第三频繁出现的单词。

包含完整源代码的笔记本可以在github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter07/Chapter7_IMDB_sentiment_analysis.ipynb找到。

现在，让我们详细查看笔记本中的相关单元格：

• 安装 AutoKeras：正如我们在其他示例中提到的，笔记本顶部的这段代码负责使用 pip 包管理器安装 AutoKeras 及其依赖项：

  !pip3 install autokeras
  

• 导入必要的包：以下几行代码加载 TensorFlow、内置的 Keras Reuters 数据集、NumPy 和 AutoKeras，作为本项目所需的依赖项：

  import tensorflow as tf
  import numpy as np
  import autokeras as ak
  

• imdb_sentiment_raw 函数。查看笔记本中的代码以获取更多细节：

  (x_train, y_train), (x_test, y_test) = imdb_sentiment_raw()
  print(x_train.shape)  # (25000,)
  print(y_train.shape)  # (25000, 1)
  

  这是输出：

  (25000,)
  (25000, 1)
  

• 展示一些样本：接下来，我们可以打印出第一个样本中的一些单词，了解其包含的内容：

  print(x_train[0][:50])
  

  这是输出：

  <START> vs from it as must exporters ability whole
  

为了更清楚地看到这一点，让我们渲染一个包含最常见单词的词云。词云（也称为标签云）是一种基于文本的数据可视化技术，其中单词根据其在文本中出现的频率显示为不同的大小：

图 7.2 – 包含数据集中最频繁单词的词云

现在，是时候创建分类器模型了。

创建情感预测器

现在，我们将使用 AutoKeras TextClassifier 来找到最佳的分类模型。为了这个示例，我们将 max_trials（最大尝试的 Keras 模型数量）设置为 2；我们不需要设置 epoch 参数；而是必须定义一个 EarlyStopping 回调，设置为 2 个 epoch，这样如果验证损失在连续两个 epoch 中没有改善，训练过程将停止：

clf = ak.TextClassifier(max_trials=2)
cbs = [tf.keras.callbacks.EarlyStopping(patience=2)]

让我们运行训练过程并为训练数据集寻找最佳分类器：

clf.fit(x_train, y_train, callbacks=cbs)

这是输出：

图 7.3 – 文本分类器训练的笔记本输出

上述输出显示训练数据集的准确率在提高。

如我们所见，我们在验证集上得到了 0.28 的损失值。对于几分钟的训练来说，这还算不错。我们已经将搜索限制为两种架构（max_trials = 2）。像其他示例一样，增加此数字会给我们一个更准确的模型，但完成的时间也会更长。

评估模型

现在，是时候使用测试数据集评估最佳模型了：

clf.evaluate(x_test, y_test)

这是输出结果：

782/782 [==============================] - 41s 52ms/step - loss: 0.3118 - accuracy: 0.8724

[0.31183066964149475, 0.8723599910736084]

如我们所见，0.8724 是我们投入时间的一个非常好的最终预测准确度。

可视化模型

现在，我们可以查看最佳生成模型的架构简要概述：

model = clf.export_model()
model.summary()

这是输出结果：

图 7.4 – 最佳模型架构摘要

如我们所见，AutoKeras 在第四章中所做的分类示例中，使用 AutoKeras 进行图像分类和回归，也选择了卷积模型（Conv1D）来执行此任务。正如我们在该章开头所解释的，当输入句子的顺序对预测不重要时，这种架构表现得非常好；不同电影评论之间没有相关性。

这是该架构的可视化表示：

图 7.5 – 最佳模型架构可视化图

如你所知，生成模型并选择最佳模型是由 AutoKeras 自动完成的，但让我们更详细地解释这些模块。

每个模块表示一个层，每个层的输出都连接到下一个层的输入，除了第一个模块，其输入是文本，以及最后一个模块，其输出是预测值。Conv1D 之前的模块都是数据预处理模块，负责将文本向量化生成嵌入，以便输入到 Conv1D 模块，并通过最大池化层减少滤波器的维度。请注意，AutoKeras 还添加了几个 dropout 模块来减少过拟合。

分析特定句子的情感

现在，让我们看一下来自测试集的一些预测样本：

import tensorflow as tf
tf.get_logger().setLevel('ERROR')
def get_sentiment(val):
    return "Positive" if val == 1 else "Negative"
for i in range(10):
    print(x_test[i])
    print("label: %s, prediction: %s" % (get_sentiment(y_test[i][0]), get_sentiment(clf.predict(x_test[i:i+1])[0][0])))

这是前面代码的输出结果：

图 7.6 – 基于测试数据集前 10 个句子的某些预测

如你所见，模型预测与测试数据集前 10 个样本的标签完全匹配。

摘要

在本章中，我们学习了情感分析在现实世界中的重要性，以及如何从文本数据中提取情感并在几行代码中实现情感预测器。

在下一章，我们将介绍一个非常有趣的话题：我们将使用 AutoKeras 通过文本分类器根据新闻内容来分类新闻话题。

第八章：第八章：使用 AutoKeras 进行主题分类

有时，我们需要将某些特定的文本（如产品或电影评论）分类到一个或多个类别中，方法是为其分配标签或主题。主题分类是一种监督式机器学习技术，正是用来完成这项工作的：预测给定文本属于哪个类别。作为一种监督式模型，它需要通过一组已经分类的训练数据进行训练，包括文本及其对应的类别。

本章将主要是实践性的，因为我们在前几章为基于文本的任务打下了基础。在本章结束时，您将学会如何使用 AutoKeras 创建主题分类器，并将其应用于任何基于主题或类别的数据集。

本章将涵盖以下主要主题：

• 理解主题分类

• 使用 AutoKeras 创建一个主题分类器

• 自定义模型搜索空间

首先，让我们来看一下本章的技术要求。

技术要求

本书中的所有代码示例都可以作为 Jupyter 笔记本下载，地址为 github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。

由于代码单元可以执行，因此每个笔记本都可以自我安装；只需添加所需的代码片段即可。因此，在每个笔记本的开头，都会有一个用于环境设置的代码单元，它会安装 AutoKeras 及其依赖项。

因此，要运行本章的代码示例，您只需要一台操作系统为 Ubuntu Linux 的计算机，并安装了 Jupyter Notebook，您可以通过以下代码行来安装：

$ apt-get install python3-pip jupyter-notebook

另外，您可以使用 Google Colaboratory 运行这些笔记本，在这种情况下，您只需要一个网页浏览器。详情请见 第二章，使用 Google Colaboratory 的 AutoKeras。此外，在该章节的 安装 AutoKeras 部分，您将找到其他安装选项。

现在，让我们通过一些实际的示例，将所学知识付诸实践。

理解主题分类

我们在 第五章，使用 AutoKeras 进行文本分类和回归 中，看到过一个简单的主题分类示例，其中有一个垃圾邮件分类器的例子。在那个例子中，我们从电子邮件内容中预测了一个类别（垃圾邮件/非垃圾邮件）。在这一节中，我们将使用类似的文本分类器，将每篇文章分类到其对应的主题中。通过这样做，我们将获得一个模型，能够确定每个新闻项对应的主题（类别）。

例如，假设我们的模型输入了以下标题：

"The match could not be played due to the eruption of a tornado"

这将输出 weather 和 sports 主题，如下图所示：

图 8.1 – 新闻主题分类器的工作流

上面的图表展示了主题分类器管道的简化版本。原始文本被分类器处理，输出将是一个或多个类别。

在本章后面，我们将应用文本分类器对路透社新闻线数据集进行处理，将每篇文章分配到 46 个类别中的一个或多个。大多数文本分类的概念已经在第五章《使用 AutoKeras 进行文本分类与回归》中讲解过，因此本章我们将通过实现主题分类器以实际方式回顾其中的一些概念。

创建新闻主题分类器

我们将要创建的模型将对路透社新闻线分类数据集的新闻进行分类。它将读取每篇新闻的原始文本，并将其分类到各个部分，为每个部分分配一个标签（例如：体育、天气、旅游等）。

路透新闻线是一个包含 11,228 条来自路透社的新闻数据集，按 46 个主题进行标注。

每篇新闻的文本被编码为一个单词索引列表。这些是按数据集中的频率索引的整数。因此，在这里，整数 1 编码数据中最常见的第一个单词，2 编码第二常见的单词，依此类推。

包含完整源代码的笔记本可以在 github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter08/Chapter8_Reuters.ipynb 找到。

现在，让我们详细查看笔记本中的相关单元格：

• 安装 AutoKeras：正如我们在前面的章节中提到的，笔记本顶部的这段代码负责使用 pip 包管理器安装 AutoKeras 及其依赖项：

  !pip3 install autokeras
  

• 将 tensorflow、内置的 Keras 路透社数据集加载到内存中，以及将 numpy 和 AutoKeras 作为本项目所需的依赖项：

  import tensorflow as tf
  from tensorflow.keras.datasets import reuters 
  import numpy as np
  import autokeras as ak
  

• reuters_raw 函数。查看笔记本中的代码以了解更多细节：

  (x_train, y_train), (x_test, y_test) = reuters_raw()
  print(x_train.shape)  # (8982,)
  print(y_train.shape)  # (8982, 1)
  

  这是前面代码的输出：

  Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters.npz
  2113536/2110848 [==============================] - 0s 0us/step
  Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters_word_index.json
  557056/550378 [==============================] - 0s 0us/step
  (8982,)
  (8982, 1)
  

• 可视化数据集样本：接下来，我们可以打印出第一个样本中的一些单词，以了解其包含的内容：

  print(x_train[0][:50])
  

  这是前面代码的输出：

  <START> <UNK> <UNK> said as a result of its decemb
  

让我们看一下词云中最常见词语的分布。词云（也称为标签云）是一种基于文本的数据可视化技术，单词的显示大小取决于它们在文本中出现的频率：

图 8.2 – 新闻线数据集的词云

现在，让我们创建新闻线分类器模型。

创建分类器

现在，我们将使用 AutoKeras 的 TextClassifier 来寻找最佳的分类模型。仅此示例，我们将 max_trials（尝试的不同 Keras 模型数量的最大值）设置为 2. 我们不会设置 epochs 参数，而是定义一个 EarlyStopping 回调，设定为 2 个 epoch。这样，训练过程将在验证损失连续两个 epoch 没有改善时停止：

clf = ak.TextClassifier(max_trials=2)
cbs = [tf.keras.callbacks.EarlyStopping(patience=2)]

让我们运行训练过程，寻找训练数据集的最佳分类器：

clf.fit(x_train, y_train, callbacks=cbs)

这是输出结果：

图 8.3 – 文本分类器训练的笔记本输出

之前的输出显示了训练数据集的准确性在不断提高。

如我们所见，我们在验证集上达到了 0.965 的损失值。仅仅 1 分钟的训练时间就得到了一个非常不错的结果。我们将搜索限制为两种架构（max_trials = 2）。增加这个数字会给我们一个更精确的模型，尽管也会花费更多的时间。

评估模型

现在，是时候用测试数据集来评估最佳模型了：

Clf.evaluate(x_test, y_test)

这是输出结果：

71/71 [==============================] – 1s 7ms/step – loss: 0.9743 – accuracy: 0.7778
[0.9742580652236938, 0.777827262878418]

如我们所见，0.77（77%）是我们投入训练时间（不到几分钟）后得到的一个不错的最终预测得分。

可视化模型

现在，让我们来看一下最佳生成模型的架构简要总结：

Model = clf.export_model()
model.summary()

这是输出结果：

图 8.4 – 最佳模型架构总结

如我们所见，AutoKeras 已选择了一个卷积模型（Conv1D）来执行这个任务。正如我们在本章开头所解释的，当序列中元素的顺序对预测没有重要影响时，这种架构效果很好。

这是它的可视化表示：

图 8.5 – 最佳模型架构可视化

评估模型

如你所知，生成模型并选择最佳模型是由 AutoKeras 自动完成的，但我们来更详细地解释这些模块。

每个模块代表一个层级，且每个模块的输出都与下一个模块的输入相连，除了第一个模块，其输入是文本，最后一个模块，其输出是预测的数字。在 Conv1D 之前的模块都是数据预处理模块，负责将文本向量化，生成嵌入以供 Conv1D 模块使用，并通过最大池化层减少滤波器的维度。请注意，AutoKeras 还添加了几个 dropout 模块以减少过拟合。

自定义模型搜索空间

我们可以通过使用 AutoModel 替代 TextClassifier 来自定义模型的搜索空间，例如，通过为某些特定配置设置 TextBlock。

在以下代码片段中，我们告诉 AutoKeras 只生成使用'ngram'来向量化句子的模型。记住，如果我们没有指定这些参数，AutoKeras 将自动尝试所有可能的组合，直到数量达到max_trial参数所设定的值：

input_node = ak.TextInput()
output_node = ak.TextBlock(block_type="ngram")(input_node)
output_node = ak.ClassificationHead()(output_node)
clf = ak.AutoModel(inputs=input_node, 
                   outputs=output_node, overwrite=True,
                   max_trials=1)
clf.fit(x_train, y_train, epochs=2)

现在，让我们总结一下本章所学内容。

总结

在本章中，我们学习了如何通过实现一个高性能的文本分类器来解决一个主题分类任务，该分类器可以在仅仅几行代码的情况下对新闻文章进行分类。

现在我们已经为处理文本打下了基础，接下来我们可以进入下一章，在那里你将学习如何使用 AutoKeras 处理多模态和多任务数据。

第三部分：高级 AutoKeras

在本节中，您将学习一些 AutoKeras 的高级概念，包括处理多模态数据和多任务、使用 AutoModel 定制模型、导出/部署模型，以及使用 AutoKeras 扩展功能。

本节包括以下章节：

• 第九章**，处理多模态数据和多任务

• 第十章**，导出与可视化模型

第九章：第九章：处理多模态和多任务数据

在本章中，我们将学习如何使用 AutoModel API 来处理多模态和多任务数据。

到本章结束时，你将学会如何使用创建具有多个输入和多个输出的模型所需的概念和工具。你将能够通过从头开始创建模型或将本章展示的实际示例适应其他相似数据集，将这些概念应用到自己的项目中。

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

• 探索具有多个输入或输出的模型

• 创建一个多任务/多模态模型

• 自定义搜索空间

但首先，让我们解释一下本章的技术要求。

技术要求

本书中的所有代码示例都可以作为 Jupyter 笔记本下载，下载地址是github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。

由于代码单元可以执行，因此每个笔记本都可以自我安装；只需添加包含所需依赖项的代码片段。因此，在每个笔记本的开头，都有一个用于环境设置的代码单元，用来安装 AutoKeras 及其依赖项。

因此，为了运行本章中的代码示例，你只需要一台运行 Ubuntu Linux 操作系统的计算机，并且必须通过以下代码行安装 Jupyter Notebook：

$ apt-get install python3-pip jupyter-notebook

另外，你也可以使用 Google Colaboratory 运行这些笔记本，在这种情况下，你只需要一个网页浏览器。有关详细信息，请参见第二章，AutoKeras 与 Google Colaboratory。此外，在该章节的安装 AutoKeras部分，你将找到其他安装选项。

现在，让我们通过一个实际示例来实践在介绍中提到的这些概念。

探索具有多个输入或输出的模型

正如我们稍后将看到的，有时我们可能希望我们的模型同时获取来自不同来源的信息（多模态）和/或同时预测多个目标（多任务）。AutoKeras 有一个叫做AutoModel的类，允许我们将多个来源和目标定义为一组参数列表。在看实际示例之前，让我们稍微深入了解一下这个内容。

什么是 AutoModel？

AutoModel 是一个类，允许我们通过定义不仅是输入和输出，还包括其内部层来精细地定义模型。

它可以通过两种不同的方式使用：

• 基本：在这里，输入/输出节点被指定，AutoModel 推断模型的其余部分。

• 高级：在这里，高级架构通过使用功能 API 连接各层（模块）来定义，这与 Keras 的功能 API 相同。

让我们看一下每个示例。

基本示例

用户只需指定输入节点和输出头：

import autokeras as ak
ak.AutoModel(
    inputs=[ak.ImageInput(), ak.TextInput()],
    outputs[ak.ClassificationHead(), ak.RegressionHead()])

接下来，让我们看一个高级示例。

高级示例

用户指定高级架构：

import autokeras as ak
image_input = ak.ImageInput()
image_output = ak.ImageBlock()(image_input)
text_input = ak.TextInput()
text_output = ak.TextBlock()(text_input)
output = ak.Merge()([image_output, text_output])
classification_output = ak.ClassificationHead()(output)
regression_output = ak.RegressionHead()(output)
ak.AutoModel(
   inputs=[image_input, text_input],
   outputs=[classification_output, regression_output])

在前面的代码中，我们配置了 AutoModel 以创建一个具有多个输入（多模态）和多个输出（多任务）的模型。接下来，我们将解释这些概念，并通过创建自己的多模态模型来实际应用它们。

什么是多模态？

我们称数据为多模态数据，当每个数据实例包含多种信息形式时。例如，我们可以将一张照片保存为图像，但除了这张图像，它还包含关于拍摄地点的元信息。这些元信息可以视为结构化数据。

什么是多任务？

我们称一个模型为多任务模型，当它使用相同的输入特征预测多个目标时。例如，假设我们想按族群分类人物照片，同时还希望指定其年龄，年龄范围为 0 到 100。

下图展示了一个多模态和多任务神经网络模型的示例：

图 9.1 – 多模态和多任务神经网络模型示例

在这里，我们可以看到有两个条目：图像（ImageInput）和结构化数据（StructuredDataInput）。每个图像都与结构化数据中的一组属性相关联。通过这些数据，我们可以尝试同时预测分类标签（ClassificationHead）和回归值（RegressionHead）。

让我们通过实际示例更详细地了解这些概念。

创建一个多任务/多模态模型

基于本章开头提供的示例，我们将创建一个模型，该模型将图像及其结构化数据属性作为输入，并预测一个类别值和一个标量值。在这种情况下，我们将不使用现有数据集，而是生成我们自己的数据。我们将使用的笔记本，包含完整的源代码，可以在 github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras/blob/main/Chapter09/Chapter9_MultiModel.ipynb 上找到。

现在，让我们详细查看笔记本中的相关单元格：

• 安装 AutoKeras：正如我们在前几章中提到的，笔记本顶部的这段代码负责使用 pip 包管理器安装 AutoKeras 及其依赖项：

  !pip3 install autokeras
  

• numpy 和 AutoKeras 是该项目所需的依赖项：

  import numpy as np
  import autokeras as ak
  

• 创建数据集：首先，我们将通过生成随机图像和结构化数据作为多模态数据来创建数据集：

  import numpy as npnum_instances = 100
  image_data = np.random.rand(num_instances, 32, 32, 3).astype(np.float32)
  structured_data = np.random.rand(num_instances, 20).astype(np.float32)
  

  现在，生成一些用于分类和回归的多任务目标：

  regression_target = np.random.rand(num_instances, 1).astype(np.float32)
  classification_target = np.random.randint(5, size=num_instances)
  

现在，是时候创建模型了。

创建模型

现在，我们将使用AutoModel创建模型，首先是基本配置，然后是高级配置。与之前的示例一样，我们将设置较小的max_trials和epochs，以避免训练过程花费太长时间。

首先，我们将使用多个输入和输出初始化模型：

import autokeras as akmodel = ak.AutoModel(
    inputs=[ak.ImageInput(), ak.StructuredDataInput()],
    outputs=[
        ak.RegressionHead(metrics=['mae']),
        ak.ClassificationHead(loss='categorical_crossentropy', metrics=['accuracy'])
    ],
    overwrite=True,
    max_trials=2)

在之前的代码中，我们定义了两个输入（图像和结构化数据）和两个输出（回归和分类）。在这里，我们告诉模型，我们希望同时使用回归器和分类器来训练输入数据。

现在，让我们运行训练过程，以搜索适合训练数据集的最佳模型：

model.fit(
    [image_data, structured_data],
    [regression_target, classification_target],
    epochs=3)

这是输出结果：

图 9.2 – 模型训练的笔记本输出

与之前的示例不同，在这里，我们可以看到输出显示了两个损失值——一个用于回归器，另一个用于分类器。在这种情况下，数据是随机生成的，因此没有必要关注性能评估。

可视化模型

现在，让我们看看最佳生成模型的架构摘要：

keras_model = model.export_model()
keras_model.summary()

这是输出结果：

图 9.3 – 最佳模型架构总结

让我们简要描述一下用于该模型的各个模块。

在这种情况下，AutoKeras 创建了两个子模型——每个输入数据对应一个子模型。它选择了一个深度残差网络架构（resnet50），该架构我们已经在第四章中介绍过，使用 AutoKeras 进行图像分类和回归，用于处理图像数据，以及几个全连接层用于处理结构化数据。在消化了这两种数据源之后，两个子模型的结果被连接起来，再分开生成两个不同的输出（一个标量值和一个分类值）。

这里是该过程的可视化表示：

图 9.4 – 最佳模型架构可视化

现在，让我们在更高级的模式下使用 AutoModel，定制中间模块。

定制搜索空间

正如我们在本章开头提到的，使用 AutoModel 有一种高级方式。我们可以通过使用功能性 API 来定义整个模型架构，将层（模块）连接起来，这与 Keras 的功能性 API 相同。

让我们在以下示例中进行操作：

input_node1 = ak.ImageInput()
output_node = ak.Normalization()(input_node1)
output_node = ak.ImageAugmentation()(output_node)
output_node1 = ak.ConvBlock()(output_node)
output_node2 = ak.ResNetBlock(version='v2')(output_node)
output_node1 = ak.Merge()([output_node1, output_node2])

input_node2 = ak.StructuredDataInput()
output_node = ak.CategoricalToNumerical()(input_node2)
output_node2 = ak.DenseBlock()(output_node)

output_node = ak.Merge()([output_node1, output_node2])
output_node1 = ak.ClassificationHead()(output_node)
output_node2 = ak.RegressionHead()(output_node)

model = ak.AutoModel(
    inputs=[input_node1, input_node2], 
    outputs=[output_node1, output_node2],
    overwrite=True,
    max_trials=2)

model.fit(
    [image_data, structured_data],
    [classification_target, regression_target],
    batch_size=32,
    epochs=3)

在这里，我们通过将一个模块的输出连接到下一个模块的输入，按顺序定义了每个模块。在这种情况下，我们通过添加一些图像预处理模块来进行定制，目的是进行归一化和数据增强。我们还将一个卷积层与 ResNet 层并行放置，以训练图像数据，该层也已进行定制。你甚至可以指定要使用的 ResNet 架构版本。

尽管这种模式更复杂，但它更强大且更灵活。请注意，你甚至可以指定想要使用的 ResNet 架构版本（v2）。需要注意的是，对于那些未自定义的参数（如版本），AutoKeras 会尝试不同的值组合，以找到最优解。

总结

在本章中，我们学习了什么是多任务模型，什么是多模态模型，以及如何使用强大的 AutoModel 类创建具有多个输入和输出的高效模型。现在，你已经准备好将这些概念应用到自己的多模态项目中，可以从头开始创建，或者通过调整这个实用示例来适应你自己的数据集。

在下一章中，我们将学习如何导出我们的模型，以及如何使用一个强大的可视化工具来实时跟踪和可视化诸如损失和准确率等指标的图形。

第十章：第十章：导出与可视化模型

在本章中，我们将学习如何导出和导入我们的 AutoKeras 模型。训练完成后，我们还将学习如何以图形方式实时可视化模型训练过程中发生的事情。

完成本章后，您将能够将模型导出和导入到磁盘，并且您将拥有一个强大的可视化工具，帮助您了解在模型训练过程中发生的情况。

本章将重点讲解以下要点：

• 导出您的模型：如何从磁盘保存和加载模型

• 使用 TensorBoard 可视化您的模型：如何使用这个强大的工具实时可视化您的模型

• 使用 ClearML 可视化和比较您的模型

让我们从第一点开始，但首先像往常一样确保我们已经安装了所有的要求。

技术要求

本书中的所有编码示例均以 Jupyter 笔记本形式提供，可以从以下网站下载：github.com/PacktPublishing/Automated-Machine-Learning-with-AutoKeras。

由于代码单元可以执行，每个笔记本都可以自我安装，您只需添加包含所需要求的代码片段。因此，在每个笔记本的开始部分，都会有一个代码单元用于环境设置，安装 AutoKeras 及其依赖项。

因此，为了运行编码示例，您只需要一台运行 Ubuntu Linux 操作系统的计算机，并可以使用以下命令安装 Jupyter notebook：

$ apt-get install python3-pip jupyter-notebook

另外，您也可以使用 Google Colaboratory 运行这些笔记本。在这种情况下，您只需要一个网页浏览器；有关详细信息，请参阅第二章中的AutoKeras 与 Google Colaboratory部分，AutoKeras 入门。此外，在主要章节安装 AutoKeras中，您还可以找到其他安装选项。

现在，让我们通过一个实际示例将上一节中的概念付诸实践。

导出模型

AutoKeras 找到的最佳模型可以轻松导出为 Keras 模型。

在将模型保存到磁盘时，可以选择两种不同的格式：TensorFlow SavedModel 格式和较旧的 Keras H5 格式。推荐使用 SavedModel 格式，这是我们调用model.save()时的默认选项。

如何保存和加载模型

现在，让我们一步步来看如何导出和恢复模型：

1. 使用以下代码块将模型导出为 Keras 模型：

   model = my_autokeras_model.export_model() 
   

   现在，尝试使用 h5 格式作为备份保存为 TensorFlow 格式，因为出现了问题：

   try:
       model.save("model_autokeras", save_format="tf")
   except:
       model.save("model_autokeras.h5")
   

2. 使用以下代码块重新加载模型：

   from tensorflow.keras.models import load_model
   loaded_model = load_model("model_autokeras", custom_objects=ak.CUSTOM_OBJECTS)
   

代码几乎不需要解释，但我们将详细说明加载功能。在这个函数中，负责将模型从磁盘加载到内存中，我们将 ak.CUSTOM_OBJECTS 作为 custom_objects 参数传递。这告诉 Keras 函数我们要加载的模型具有自定义的 AutoKeras 对象。

一旦我们知道如何导入和导出模型，就该进入下一部分，在这一部分中，我们将学习在训练过程中进行可视化。这将帮助我们从学习过程提取观点。

使用 TensorBoard 可视化你的模型

为了开发高效且成功的模型，你需要了解实验过程中发生的事情，以便尽早反应，修正可能的异常或不想要的结果，例如过拟合和学习缓慢。这就是触觉回调概念发挥作用的地方。

回调是一个对象（实现特定方法的类实例），它在调用拟合时传递给模型，并且在训练过程中模型会在不同的时刻调用它。你可以访问模型状态和性能的所有可用数据，并根据这些数据采取以下措施：

• 中断训练，因为你已经停止学习或正在过拟合

• 保存模型；这样，训练可以从保存的点在未来恢复

• 记录度量指标，例如精度或损失

• 更改其状态，并修改其结构或超参数，例如学习率

以下是使用回调的一些示例：

• 模型检查点：在训练过程中的不同点保存当前模型的权重。

• 提前停止：当验证的损失不再改善时中断训练（并且当然保存训练过程中获得的最佳模型）。

• 在训练过程中动态调整某些参数的值，例如学习率。

• 在训练过程中记录训练和验证指标，或查看模型学习的表示方式，随着更新而变化。

有两个特别有用的回调函数用于训练，EarlyStopping 和 ModelCheckpoint。第一个用于在观察到的指标停止改进时中断训练，直到初始设置的次数。例如，使用此回调可以在开始过拟合时中断训练，从而避免需要用更少的轮次重新训练模型。这个回调通常与 ModelCheckpoint 一起使用，后者允许在训练过程中不断保存模型。

图 10.1 – 使用回调训练模型的示例

AutoKeras 会在训练过程中始终保存最好的模型，并默认使用 EarlyStopping，设定的 epoch 数量根据我们训练的模型类型而有所不同。不过，这种行为可以通过回调函数的 fit 参数进行自定义。

使用回调函数记录模型状态

记录指标的回调函数对于监控至关重要，因为它们允许像 TensorBoard 这样的工具实时可视化模型在训练过程中的学习进展，正如我们在这里所看到的。

因此，在我们的案例中，我们将设置回调函数来记录训练进度，使用以下命令：

logdir = os.path.join("logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1)

在之前的代码中，我们定义了一个日志目录（log_dir），并创建了一个回调函数将模型检查点保存到该目录，这意味着 AutoKeras 会自动将每个 epoch 的指标保存到该文件夹中的多个日志文件中。我们还激活了直方图（histogram_freq=1），因此在 TensorBoard 的直方图标签中，你可以查看每一层的激活值的直方图。

在下一节中，我们将使用 TensorBoard 可视化日志，它是一个用于查看 TensorFlow 模型信息的 web 应用。由于 AutoKeras 是基于 TensorFlow 的，我们可以通过这种简单方式使用该工具来可视化我们的模型。

设置和加载 TensorBoard

TensorBoard 允许我们实时可视化不同的指标，例如损失和精度，同时渲染模型图（按层和操作分层），并显示权重、偏置或其他张量的直方图。

TensorBoard 可以直接在 Jupyter notebook 和 Colab 中使用。通过在 notebook 中加载 TensorBoard 扩展，可以实现这一功能。这是我们在本章中将采用的方法。

注意

如果你已经在同一个虚拟环境中安装了 Jupyter 和 TensorBoard，那么应该可以直接使用。如果你使用的是更复杂的设置，例如全局安装了 Jupyter 并为不同的 Conda/virtualenv 环境配置了内核，那么你需要确保 TensorBoard 二进制文件在 Jupyter notebook 的上下文中已经添加到 PATH。

首先，我们需要设置 callbacks，正如在上一节中解释的那样，记录训练进度到 logs 目录：

logdir = os.path.join("logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir)

现在我们将 callbacks 传递给训练函数：

model.fit(x_train, 
        y_train,
        epochs=1, 
        callbacks=[tensorboard_callback])

一旦训练完成，我们就可以加载 tensorboard 扩展来可视化结果：

%load_ext tensorboard
%tensorboard --logdir logs

上述代码行加载了 TensorBoard 仪表板，并将模型的 logs 目录作为输入：

图 10.2 – TensorBoard 显示模型训练结果

在之前的截图中，有两个图形，每个图形上有四条不同的线，表示两个候选模型的学习进度。

在第一个图中，两个最高的曲线分别显示了训练集和验证集的 epoch 精度，而较低的曲线则显示了另一个模型在训练集和验证集上的精度。

第二个图表中也发生了类似的情况，但在这种情况下，它表示的是损失值，而不是准确率。

我们还可以在 GRAPHS 标签页中看到模型的各个元素。GRAPHS 标签页显示了一个交互式低级 TensorFlow 图，展示了你的 AutoKeras 模型使用的特征：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_10_03.jpg)

图 10.3 – TensorBoard 显示模型图

在前面的截图中，我们可以看到模型图的一部分，以及它的不同层和操作。正如你所看到的，模型比你预期的要复杂得多。当你定义分类器时，代码只有三行，但在幕后，AutoKeras 构建了一个相当复杂的图结构来使其工作。

在这里，我们还可以可视化不同层中的权重/偏差分布：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_10_04.jpg)

图 10.4 – TensorBoard 显示模型层的分布

还有许多其他可用的选项，我们在此不做详细解释。TensorBoard 是一个非常强大且完整的工具，它的功能范围超出了本书的讨论。以下网址是一个很好的起点：www.tensorflow.org/tensorboard/get_started。

现在，让我们在下一节中看看如何将我们的实验分享给全世界。

使用 TensorBoard.dev 分享你的 ML 实验结果

TensorBoard.dev 是一个免费的公共服务，允许你上传 TensorBoard 记录并获得一个永久链接，可以与任何人分享，同时也可以用于你的学术文章、博客、社交媒体等。这可以提高实验的可重复性和协作性。

你可以通过运行以下命令简单地使用 TensorBoard.dev：

!tensorboard dev upload \
  --logdir logs/fit \
  --name "(optional) My latest AutoKeras experiment" \
  --description "(optional) Simple comparison of several hyperparameters" \
  --one_shot

上面的命令会将模型的 logs 目录上传到 TensorBoard.dev：

New experiment created. View your TensorBoard at: https://tensorboard.dev/experiment/TPcKbLPeRAqZ1GmRWDAdow/

现在，点击链接将会打开一个浏览器，在其中我们可以看到 TensorBoard 面板，网址显示为 TensorBoard.dev 网站，如下所示：

图 10.5 – 在 TensorBoard.dev 上分享的模型训练结果

正如我们所看到的，TensorBoard 是一个非常强大的工具，用于监控你的模型，但如果你需要追踪实验结果，并与其他团队进行比较和共享，那么有一个名为 ClearML 的 AutoKeras 扩展专门用于监控和追踪实验，它允许访问 TensorBoard 日志，并为其补充了许多额外的功能。我们将在下一节中详细了解这一点。

使用 ClearML 可视化和比较你的模型

ClearML（前身为 Trains）是一个完整的开源 ML/DL 实验解决方案，它会自动跟踪你需要的所有内容，帮助你记录工作、可视化结果，并通过直观的 Web 界面重现、调整和比较实验。

ClearML 允许你执行以下任务：

• 在 ClearML Web UI 中可视化实验结果。

• 跟踪并上传模型。

• 跟踪模型性能并创建跟踪排行榜。

• 重新运行实验，在任何目标机器上重现实验，并调整实验。

• 比较实验。

要在你的 AutoKeras 项目中使用它，你只需要在代码中初始化一个 ClearML 任务，ClearML 会自动记录报告给 TensorBoard、Matplotlib、Plotly 和 Seaborn 的标量、图形和图像，以及你添加到代码中的所有其他自动日志和显式报告。

将 ClearML 添加到代码中

只需将这两行代码添加到你的项目中：

from clearml import Task
task = Task.init(project_name="myAutokerasProject", task_name="myAutokerasExperiment")

当代码运行时，它会在 ClearML 服务器中初始化一个任务，并在控制台输出指向实验日志的超链接：

CLEARML Task: created new task id=c1f1dc6cf2ee4ec88cd1f6184344ca4e
CLEARML results page: https://app.clearml-master.hosted.allegro.ai/projects/1c7a45633c554b8294fa6dcc3b1f2d4d/experiments/c1f1dc6cf2ee4ec88cd1f6184344ca4e/output/log

ClearML 会检查 AutoKeras 的训练过程，查找 TensorBoard 回调函数，以及任何类型的输出，包括日志、指标、图像等。

在生成的实验链接中，你可以实时查看与 AutoKeras 自动生成的模型相关的仪表板，这些仪表板包含不同的图表。这些图表会在训练过程中生成，并且可以看到它们的准确性、在训练和评估数据集上的表现、控制台输出以及更多的指标：

图 10.6 – ClearML 仪表板显示 TensorBoard 指标

在之前的截图中，我们可以看到我们的模型在各个训练轮次中的精度和损失变化，在接下来的截图中，我们可以看到其中一个卷积层的权重分布：

图 10.7 – ClearML 仪表板显示一些模型层分布

在之前的截图中，我们可以看到类似于之前 TensorBoard 仪表板中的 ClearML 面板。

AutoKeras 在训练过程中会生成多个模型，所以让我们看看 ClearML 如何同时展示每个模型的结果。

比较实验

使用此工具，你还可以强有力地比较实验并对比结果。有许多比较选项，例如比较模型工件、超参数、数据系列图和每次迭代的调试样本。它还允许你使用查看器（用于图像和视频）和播放器（用于音频）浏览样本：

](https://github.com/OpenDocCN/freelearn-dl-pt5-zh/raw/master/docs/auto-ml-autokeras/img/B16953_10_08.jpg)

图 10.8 – ClearML 仪表板比较两个模型的训练结果

这些选项的详细信息以及更多内容可以在 ClearML Web UI 文档中找到。

摘要

在本章中，我们学习了如何定义 Keras 回调函数以在训练过程中监控模型，如何使用 TensorBoard 查看直方图、模型图表和其他许多指标，并且如何使用 ClearML 扩展来监控和跟踪实验。

使用这些新工具，你将能更好地在现实世界中构建深度学习模型并调试潜在的问题。

本书中，我们学习了使用 AutoKeras 解决基于文本、图像或结构化数据的任务所需的基本概念，以及本章中看到的可视化技术。AutoKeras、Keras 和 TensorFlow 都有出色的文档，你可以根据需要深入研究。基础已经打好，现在是时候完成建设了。

最后的几句话

这就是《使用 AutoKeras 进行自动化机器学习》的结束！我希望你已经学会了，它将帮助你实现自己的 AI 项目，或者提升你已有的项目，特别是在 AI 领域，每天都有新的概念诞生。因此，我鼓励你继续前行，深入探索这个令人兴奋的世界，享受每一步。

在西班牙的圣地亚哥之路上，经常有一句话被反复提到：“旅行者，路并不存在。路是走出来的。”

我希望这本书能作为一个起点，帮助你继续走这条路。