包含 Keras 和 TPU 的卷积神经网络

1. 概览

在本实验中，您将学习如何将卷积层组装到可识别花朵的神经网络模型中。这次，您将从头开始自行构建模型，并利用 TPU 的强大功能在几秒钟内训练模型并迭代其设计。

本实验包含有关卷积神经网络的必要理论说明，是开发者学习深度学习的良好起点。

本实验是“Keras on TPU”系列实验的第 3 部分。您可以按以下顺序执行这些步骤，也可以单独执行。

• TPU 速度数据流水线：tf.data.Dataset 和 TFRecords
• 您的第一个 Keras 模型，采用迁移学习
• [本实验] 使用 Keras 和 TPU 的卷积神经网络
• 现代卷积神经网络、squeezenet、Xception 以及 Keras 和 TPU

学习内容

• 使用 Keras 序列模型构建卷积图片分类器。
• 在 TPU 上训练 Keras 模型
• 通过选择合适的卷积层来微调模型。

反馈

如果您在此 Codelab 中发现任何问题，请告诉我们。您可以通过 GitHub 问题 [反馈链接] 提供反馈。

2. Google Colaboratory 快速入门

本实验使用 Google Colaboratory，无需您进行任何设置。Colaboratory 是一个在线笔记本平台，可用于教育目的。它提供免费的 CPU、GPU 和 TPU 训练。

您可以打开此示例笔记本并运行几个单元格，以便熟悉 Colaboratory。

Welcome to Colab.ipynb

选择 TPU 后端

在 Colab 菜单中，依次选择运行时 > 更改运行时类型，然后选择 TPU。在此代码实验中，您将使用强大的 TPU（张量处理单元）来支持硬件加速训练。首次执行时，系统会自动连接到运行时，您也可以使用右上角的“连接”按钮。

笔记本执行

点击某个单元格，然后使用 Shift-Enter 逐个执行单元格。您还可以通过依次选择运行时 > 全部运行来运行整个笔记本

目录

所有笔记本都有目录。您可以使用左侧的黑色箭头打开该菜单。

隐藏单元格

部分单元格将仅显示其标题。这是 Colab 特有的笔记本功能。您可以双击它们来查看其中的代码，但通常不会很有趣。通常是支持或可视化函数。您仍需运行这些单元格，以便定义其中的函数。

Authentication

只要您使用已获授权的账号进行身份验证，Colab 就可以访问您的私有 Google Cloud Storage 存储分区。上述代码段将触发身份验证流程。

3. [信息] 什么是张量处理单元 (TPU)？

简而言之

TPU 是一种专门用于深度学习任务的硬件加速器。在此代码实验中，您将了解如何将它们与 Keras 和 TensorFlow 2 搭配使用。Cloud TPU 提供 8 核的基本配置，还提供称为“TPU Pod”的更大配置，最多可包含 2048 个核心。额外的硬件可用于通过增加训练批次大小来加速训练。

在 Keras 中训练 TPU 模型的代码（如果 TPU 不可用，则回退到 GPU 或 CPU）：

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

我们今天将使用 TPU 以交互式速度（每次训练运行只需几分钟）构建和优化花卉分类器。

为什么选择 TPU？

现代 GPU 围绕可编程的“核心”构建，这种非常灵活的架构使它们能够处理各种任务，例如 3D 渲染、深度学习、物理模拟等。另一方面，TPU 将经典矢量处理器与专用矩阵乘法单元配对，擅长处理以大型矩阵乘法为主的任何任务，例如神经网络。

图示：密集神经网络层作为矩阵乘法，一次通过神经网络处理一批八张图片。请运行一行 x 列乘法，以验证它是否确实在对图像的所有像素值进行加权求和。卷积层也可以表示为矩阵乘法，不过会稍微复杂一些（ 相关说明请参阅第 1 部分）。

硬件

MXU 和 VPU

TPU v2 核心由一个用于运行矩阵乘法的矩阵乘法单元 (MXU) 和一个用于执行所有其他任务（例如激活、softmax 等）的向量处理单元 (VPU) 组成。VPU 可处理 float32 和 int32 计算。另一方面，MXU 以混合精度 16-32 位浮点格式运行。

混合精度浮点和 bfloat16

MXU 使用 bfloat16 输入和 float32 输出计算矩阵乘法。中间累积以 float32 精度执行。

神经网络训练通常能够抵抗因浮点精度降低而引入的噪声。在某些情况下，噪声甚至有助于优化器收敛。16 位浮点精度传统上用于加速计算，但 float16 和 float32 格式的范围差异很大。将精度从 float32 降低到 float16 通常会导致上溢和下溢。虽然有解决方案，但通常需要额外的工作才能使 float16 正常运行。

因此，Google 在 TPU 中引入了 bfloat16 格式。bfloat16 是一种截断的 float32，具有与 float32 完全相同的指数位和范围。此外，TPU 以混合精度计算矩阵乘法，输入为 bfloat16，输出为 float32，这意味着，通常无需更改代码即可受益于精度降低带来的性能提升。

在 TPU 上，默认使用 bfloat16/float32 混合精度。您无需对 TensorFlow 代码进行任何更改即可启用此功能。您仍然可以在整个代码中使用 float32。执行矩阵乘法时，TPU 会自动将输入截断为 bfloat16。生成的矩阵为 float32。

脉动阵列

MXU 在硬件中实现矩阵乘法，采用所谓的“脉动阵列”架构，其中数据元素流经硬件计算单元阵列。（在医学上，“收缩”是指心脏收缩和血流（量），这里是指数据流。）

矩阵乘法的基本要素是一个矩阵中的一行与另一个矩阵中的一列之间的点积（请参阅本部分顶部的图示）。对于矩阵乘法 Y=X*W，结果的一个元素将为：

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

在 GPU 上，人们会将此点积编程到 GPU“核心”中，然后并行地在尽可能多的“核心”上执行该点积，以尝试一次性计算出结果矩阵的每个值。如果生成的矩阵大小为 128x128，则需要 128x128=16K 个“核心”，这通常是不可能的。最大的 GPU 拥有大约 4000 个核心。另一方面，TPU 仅使用 MXU 中计算单元所需的最低限度的硬件：只有 bfloat16 x bfloat16 => float32 个乘法累加器，没有其他任何东西。这些矩阵非常小，TPU 可以在 128x128 MXU 中实现 16K 个这样的矩阵，并一次性处理此矩阵乘法。

图示：MXU 脉动阵列。计算元素是乘法累加器。一个矩阵的值会加载到数组中（红点）。其他矩阵的值会流经数组（灰色圆点）。竖线将值向上传播。横线用于传播部分和。用户可以自行验证，当数据流经数组时，您会从右侧获得矩阵乘法的结果。

此外，在 MXU 中计算点积时，中间和仅在相邻的计算单元之间流动。它们无需存储和检索到内存或寄存器文件。最终结果是，在计算矩阵乘法时，TPU 脉动阵列架构在密度和能耗方面具有显著优势，在速度方面也具有不可忽略的优势。

Cloud TPU

当您在 Google Cloud Platform 上请求一个“Cloud TPU v2”时，您会获得一个具有 PCI 连接的 TPU 板的虚拟机 (VM)。TPU 板有四个双核 TPU 芯片。每个 TPU 核心都包含一个 VPU（向量处理单元）和一个 128x128 MXU（矩阵乘法单元）。然后，此“Cloud TPU”通常通过网络连接到请求它的虚拟机。因此，完整的情况如下所示：

图示：您的虚拟机，其中包含一个网络连接的“Cloud TPU”加速器。“Cloud TPU”本身由一个虚拟机组成，该虚拟机具有一个 PCI 连接的 TPU 板，该板上包含四个双核 TPU 芯片。

TPU Pod

在 Google 的数据中心内，TPU 连接到高性能计算 (HPC) 互连，这使得它们看起来像一个非常大的加速器。Google 将它们称为 Pod，它们最多可包含 512 个 TPU v2 核心或 2048 个 TPU v3 核心。

图示：TPU v3 pod。通过 HPC 互连连接的 TPU 板和机架。

在训练期间，TPU 核心之间会使用全缩减算法交换梯度（此处对全缩减进行了很好的说明）。正在训练的模型可以通过以大批次大小进行训练来利用硬件。

图示：在 Google TPU 的二维环面网状网 HPC 网络上，使用 all-reduce 算法在训练期间同步梯度。

软件

大批次大小训练

TPU 的理想批次大小为每个 TPU 核心 128 个数据项，但硬件从每个 TPU 核心 8 个数据项开始就能显示出良好的利用率。请注意，一个 Cloud TPU 有 8 个核心。

在此 Codelab 中，我们将使用 Keras API。在 Keras 中，您指定的批次是整个 TPU 的全局批次大小。系统会自动将批次拆分为 8 个，并在 TPU 的 8 个核心上运行。

如需了解其他性能提示，请参阅 TPU 性能指南。对于非常大的批次大小，某些模型可能需要特别注意，请参阅 LARSOptimizer 了解详情。

深入了解：XLA

TensorFlow 程序定义计算图。TPU 不会直接运行 Python 代码，而是运行由 TensorFlow 程序定义的计算图。在底层，一个名为 XLA（加速线性代数编译器）的编译器会将计算节点的 TensorFlow 图转换为 TPU 机器代码。此编译器还会对您的代码和内存布局执行许多高级优化。当工作发送到 TPU 时，系统会自动进行编译。您不必在构建链中明确添加 XLA。

图示：为了在 TPU 上运行，Tensorflow 程序定义的计算图首先会被转换为 XLA（加速线性代数编译器）表示法，然后由 XLA 编译为 TPU 机器码。

在 Keras 中使用 TPU

从 TensorFlow 2.1 开始，Keras API 支持 TPU。Keras 支持可在 TPU 和 TPU Pod 上运行。以下示例适用于 TPU、GPU 和 CPU：

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

在此代码段中：

• TPUClusterResolver().connect() 在网络上查找 TPU。在大多数 Google Cloud 系统（AI Platform 作业、Colaboratory、Kubeflow、通过“ctpu up”实用程序创建的深度学习虚拟机）上，该函数无需参数即可运行。这些系统通过 TPU_NAME 环境变量知道其 TPU 的位置。如果您手动创建 TPU，请在您要使用的虚拟机上设置 TPU_NAME 环境变量，或使用显式参数调用 TPUClusterResolver：TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy 是实现分布式和“全归约”梯度同步算法的部分。
• 策略通过范围应用。必须在 strategy 范围() 内定义模型。
• tpu_model.fit 函数需要一个 tf.data.Dataset 对象作为 TPU 训练的输入。

常见的 TPU 移植任务

• 虽然有很多方法可以在 TensorFlow 模型中加载数据，但对于 TPU，必须使用 tf.data.Dataset API。
• TPU 的运行速度非常快，因此在 TPU 上运行时，提取数据往往会成为瓶颈。您可以使用一些工具来检测数据瓶颈，并参考 TPU 性能指南中的其他性能提示。
• int8 或 int16 数字会被视为 int32。TPU 没有以小于 32 位运行的整数硬件。
• 不支持某些 TensorFlow 操作。点击此处可查看列表。好消息是，此限制仅适用于训练代码，即模型的前向和后向传递。您仍然可以在数据输入流水线中使用所有 TensorFlow 操作，因为这些操作将在 CPU 上执行。
• TPU 不支持 tf.py_func。

4. [信息] 神经网络分类器 101

简而言之

如果您已经了解下一段中所有粗体字词，则可以继续进行下一个练习。如果您刚刚开始学习深度学习，欢迎您，请继续阅读。

神经网络分类器由多个神经元层组成。对于图片分类，这些层可以是密集层，但更常见的是卷积层。它们通常通过 relu 激活函数激活。最后一层使用的神经元数量与类数量相同，并使用 softmax 进行激活。对于分类，交叉熵是最常用的损失函数，用于将独热编码的标签（即正确答案）与神经网络预测的概率进行比较。为了最大限度地减少损失，最好选择具有动量的优化器（例如 AdamOptimizer），并针对训练图片和标签的批次进行训练。

对于构建为层序列的模型，Keras 提供了 Sequential API。例如，使用三个密集层的图片分类器可以在 Keras 中编写为：

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

密集神经网络

这是用于对图像进行分类的最简单的神经网络。它由分层排列的“神经元”组成。第一层处理输入数据，并将其输出提供给其他层。之所以称为“密集”，是因为每个神经元都与前一层中的所有神经元相连。

您可以将图片输入到此类网络中，方法是将所有像素的 RGB 值展平为一个长向量，并将其用作输入。虽然这不是最佳的图像识别技术，但我们稍后会对其进行改进。

神经元、激活、RELU

“神经元”会计算所有输入的加权和，添加一个称为“偏差”的值，并通过所谓的“激活函数”馈送结果。权重和偏差最初是未知的。它们将随机初始化，并通过基于大量已知数据训练神经网络来“学习”。

最常用的激活函数是 RELU（修正线性单元）。如上图所示，这是一个非常简单的函数。

Softmax 激活函数

上述网络的末尾是一个 5 个神经元的层，因为我们要将花卉分为 5 个类别（玫瑰、郁金香、蒲公英、雏菊、向日葵）。中间层中的神经元使用经典的 RELU 激活函数进行激活。不过，在最后一层中，我们希望计算介于 0 到 1 之间的数字，表示相应花朵是玫瑰、郁金香等的概率。为此，我们将使用一种名为“softmax”的激活函数。

对向量应用 softmax 函数的方法是，先计算每个元素的指数，然后对向量进行归一化处理（通常使用 L1 范数，即绝对值之和），使值总和为 1，从而可以解释为概率。

为什么“softmax”被称为 softmax？指数函数是一种陡峭递增的函数。它会增加神经元输出之间的差异。然后，当您对向量进行归一化时，占主导地位的最大元素将被归一化为接近 1 的值，而所有其他元素最终将被除以一个较大的值并归一化为接近 0 的值。生成的向量清楚地显示了获胜的类别（即“最大”类别），但保留了其值的原始相对顺序，因此称为“软”。

交叉熵损失

现在，我们的神经网络可以根据输入图片生成预测结果，我们需要衡量这些结果的准确性，即网络给出的结果与正确答案（通常称为“标签”）之间的距离。请注意，我们已为数据集中的所有图片添加了正确的标签。

任何距离都可以，但对于分类问题，所谓的“交叉熵距离”是最有效的。我们将此函数称为误差或“损失”函数：

“独热编码”是指使用一个包含 5 个值的向量来表示标签“3) 蒲公英”，该向量中除第 3 个值为 1 之外，其余值均为零。此向量表示是蒲公英的概率为 100%。我们的神经网络还会以包含 5 个概率值的向量形式输出预测结果。易于比较。

梯度下降法

“训练”神经网络实际上是指使用训练图片和标签来调整权重和偏差，以最大限度地减少交叉熵损失函数。具体运作方式如下。

交叉熵是权重、偏差、训练图像的像素及其已知类别的函数。

如果我们计算相对于所有权重和所有偏差的交叉熵偏导数，就会得到一个“梯度”，该梯度是针对给定的图片、标签以及当前权重和偏差值计算得出的。请注意，我们可能有数百万个权重和偏差，因此计算梯度听起来像是一项非常繁重的工作。幸运的是，Tensorflow 可以帮我们完成这项工作。梯度的数学属性是它指向“上方”。由于我们希望前往交叉熵较低的位置，因此我们朝相反的方向前进。我们通过梯度的一小部分来更新权重和偏差。然后，我们在训练循环中，使用下一批训练图片和标签反复执行相同的操作。希望这会收敛到交叉熵最小的位置，尽管无法保证此最小值是唯一的。

“学习速率”：您无法在每次迭代时按梯度的整个长度更新权重和偏差。这就像穿着七里靴试图到达山谷底部一样。您会从山谷的一侧跳到另一侧。为了到达底部，您需要采取更小的步长，即仅使用梯度的一小部分，通常在 1/1000 范围内。这一分数称为“学习速率”。

小批次和动量

您可以仅根据一张示例图片计算梯度并立即更新权重和偏差，但如果根据一批（例如 128 张）图片计算梯度，则得到的梯度能更好地表示不同示例图片施加的限制，因此更有可能更快地收敛到解决方案。小批次的大小是一个可调整的参数。

这种有时称为“随机梯度下降法”的技术还有另一个更实用的好处：处理批次也意味着处理更大的矩阵，而这些矩阵通常更易于在 GPU 和 TPU 上进行优化。

不过，收敛可能仍然有点混乱，如果梯度向量全为零，甚至可能会停止。这是否意味着我们找到了最小值？不一定。梯度分量在最小值或最大值处可以为零。如果梯度向量有数百万个元素，并且这些元素全部为零，那么每个零都对应一个最小值，而没有一个零对应最大值的概率非常小。在多维空间中，鞍点非常常见，我们不希望停留在鞍点。

图示：鞍点。梯度为 0，但它在所有方向上都不是最小值。（图片提供方信息 维基媒体：Nicoguaro - 自制作品，CC BY 3.0）

解决方案是为优化算法增加一些动量，使其能够顺利通过鞍点而不停止。

Tensorflow 库提供了一系列优化器，从 tf.train.GradientDescentOptimizer 开始。内置动量的更高级的主流优化器包括 tf.train.RMSPropOptimizer 或 tf.train.AdamOptimizer。

术语库

批次或小批次：始终基于批次的训练数据和标签进行训练。这样做有助于算法收敛。“批次”维度通常是数据张量的第一个维度。例如，形状为 [100, 192, 192, 3] 的张量包含 100 张 192x192 像素的图片，每张图片包含三个值（RGB）。

交叉熵损失：一种常用于分类器的特殊损失函数。

密集层：一种神经元层，其中每个神经元都与上一层中的所有神经元相连。

特征：神经网络的输入有时称为“特征”。确定将数据集的哪些部分（或部分组合）馈送到神经网络以获得良好预测结果的技巧称为“特征工程”。

标签：监督式分类问题中“类别”或正确答案的另一种名称

学习速率：在训练循环的每次迭代中，权重和偏差更新所依据的梯度分数。

logits：在应用激活函数之前，神经元层的输出称为“logits”。该术语源自“logistic 函数”（也称为“S 型函数”），后者曾经是最热门的激活函数。“Neuron outputs before logistic function”（逻辑函数之前的神经元输出）缩短为“logits”。

损失：将神经网络输出与正确答案进行比较的误差函数

神经元：计算输入的加权和，添加偏差，并通过激活函数馈送结果。

独热编码：5 个类别中的第 3 个类别编码为包含 5 个元素的向量，其中第 3 个元素为 1，其余元素均为 0。

relu：修正线性单元。一种常用的神经元激活函数。

sigmoid：另一种曾经很受欢迎的激活函数，在特殊情况下仍然有用。

softmax：一种特殊的激活函数，可作用于向量，增大最大分量与所有其他分量之间的差值，还会将向量归一化为总和为 1，以便将其解读为概率向量。用作分类器的最后一步。

张量：“张量”类似于矩阵，但具有任意数量的维度。一维张量是向量。二维张量是矩阵。然后，您可以拥有 3 维、4 维、5 维或更多维度的张量。

5. [新信息] 卷积神经网络

简而言之

如果您已经了解下一段中所有粗体字词，则可以继续进行下一个练习。如果您刚刚开始使用卷积神经网络，请继续阅读。

示例：使用两个连续的滤波器（每个滤波器包含 4x4x3=48 个可学习的权重）过滤图片。

卷积神经网络会对输入图像应用一系列可学习的过滤器。卷积层由过滤条件（或内核）大小、应用的过滤条件数量和步幅定义。卷积层的输入和输出都有三个维度（宽度、高度、通道数），从输入图像（宽度、高度、RGB 通道）开始。堆叠卷积层时，可以使用步幅 >1 或通过最大池化操作来调整输出的宽度和高度。通过使用更多或更少的过滤器来调整输出的深度（渠道数量）。

下面展示了如何在 Keras 中实现一个简单的卷积神经网络：

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

卷积神经网络入门指南

在卷积网络的某一层中，一个“神经元”仅对上方一小块图像区域中的像素进行加权求和。它会添加偏差，并通过激活函数馈送总和，就像常规密集层中的神经元一样。然后，使用相同的权重对整个图片重复此操作。请注意，在密集层中，每个神经元都有自己的权重。在这里，单个权重“补丁”在图像上沿两个方向滑动（即“卷积”）。输出值的数量与图片中的像素数量相同（不过边缘需要一些填充）。它是一种过滤操作，使用 4x4x3=48 个权重的过滤条件。

不过，48 个权重是不够的。为了增加自由度，我们使用一组新的权重重复相同的操作。这会生成一组新的过滤输出。我们不妨将其称为输出“通道”，这与输入图像中的 R、G、B 通道类似。

通过添加新维度，可以将两组（或更多组）权重汇总为一个张量。这样，我们就得到了卷积层权重张量的通用形状。由于输入和输出通道的数量是形参，我们可以开始堆叠和链接卷积层。

图示：卷积神经网络将数据“立方体”转换为其他数据“立方体”。

步幅卷积、最大池化

通过以 2 或 3 的步幅执行卷积，我们还可以缩小所得数据立方体的水平维度。您可以通过以下两种常见方式来完成此操作：

• 步幅卷积：与上述滑动过滤器的不同之处在于，步幅大于 1
• 最大池化：应用 MAX 操作的滑动窗口（通常在 2x2 块上，每 2 个像素重复一次）

图示：将计算窗口滑动 3 个像素会减少输出值。步幅卷积或最大池化（以 2 为步长滑动 2x2 窗口的最大值）是一种在水平维度上缩小数据立方体的方法。

“最大池化”有助于我们直观地了解卷积网络的运作方式：假设在训练期间，权重块会演变为可识别基本形状（水平线、垂直线、曲线等）的过滤器，那么提取有用信息的一种方法是，通过各层保留以最大强度识别出形状的输出。实际上，在最大池化层中，神经元输出以 2x2 为一组进行处理，并且仅保留最大值。

Convolutional 分类器

最后，我们通过以下方式附加分类头：将最后一个数据立方体展平，然后将其馈送到密集的 softmax 激活层。典型的卷积分类器可能如下所示：

图示：使用卷积层和 softmax 层的图片分类器。它使用 3x3 和 1x1 滤波器。maxpool 层会取 2x2 数据点组的最大值。分类头是通过具有 softmax 激活的密集层实现的。

在 Keras 中

上述卷积堆栈在 Keras 中可以写成如下形式：

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

卷积层中的 padding 参数可以有两个值：

• “same”：用零填充，以生成与输入宽度/高度相同的输出
• “valid”：无内边距，仅使用实际像素

6. 您的自定义卷积神经网络

动手

让我们从头开始构建和训练卷积神经网络。使用 TPU 可以让我们非常快速地进行迭代。请打开以下笔记本，执行单元格（按 Shift-Enter 键），然后按照标有“需要完成的工作”的说明操作。

Keras_Flowers_TPU (playground).ipynb

目标是超越迁移学习模型 75% 的准确率。该模型具有优势，因为它已在包含数百万张图片的数据集上进行过预训练，而我们这里只有 3, 670 张图片。你们至少能匹配一下吗？

其他信息

有多少层，每层有多大？

选择层大小更像是一门艺术，而不是一门科学。您必须在参数（权重和偏差）过少和过多之间找到适当的平衡。如果权重过少，神经网络就无法表示花朵形状的复杂性。如果数量过多，模型可能会出现“过拟合”现象，即过于专注于训练图片，而无法进行泛化。如果参数过多，模型训练速度也会变慢。在 Keras 中，model.summary() 函数会显示模型的结构和形参数量：

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

以下是一些提示：

• 正是因为具有多个层，深度神经网络才能发挥有效作用。对于这个简单的花卉识别问题，5 到 10 层是合理的。
• 使用小过滤器。通常，3x3 滤镜在任何地方都表现良好。
• 您也可以使用 1x1 过滤条件，这种过滤条件的费用较低。它们实际上并不“过滤”任何内容，而是计算渠道的线性组合。将它们与真实过滤条件交替使用。（有关“1x1 卷积”的更多信息，请参阅下一部分。）
• 对于此类分类问题，请使用最大池化层（或步长大于 1 的卷积）频繁进行下采样。您并不关心花朵的位置，只关心它是玫瑰还是蒲公英，因此丢失 x 和 y 信息并不重要，过滤较小区域的成本也更低。
• 过滤器的数量通常会与网络末端的类数量相似（原因？请参阅下方的“全局平均池化”技巧）。如果您要分类到数百个类别，请在连续的层中逐步增加过滤器的数量。对于具有 5 个类别的花卉数据集，仅使用 5 个过滤条件进行过滤是不够的。您可以在大多数层中使用相同的过滤条件数量（例如 32），并在接近末尾时减少该数量。
• 最终密集层成本高昂。它的权重数量可能比所有卷积层的总和还要多。例如，即使最后一个数据立方体的输出非常合理，只有 24x24x10 个数据点，一个 100 个神经元的密集层也会产生 24x24x10x100=576,000 个权重！请仔细考虑，或尝试全局平均池化（见下文）。

全局平均池化

您无需在卷积神经网络的末尾使用昂贵的密集层，而是可以将传入的数据“立方体”拆分为与类别数量相同的多个部分，计算这些部分的平均值，然后通过 softmax 激活函数馈送这些平均值。这种构建分类头的方式不需要任何权重。在 Keras 中，语法为 tf.keras.layers.GlobalAveragePooling2D().

卷积神经网络可检测事物的位置。当某个滤镜对某个特征有强烈的响应时，它会在特定的 x、y 位置做出响应。根据您的需求，您可以训练神经网络使用或舍弃这些位置数据。使用全局平均池化会明确舍弃所有位置数据。这对于花卉分类器来说可能没问题，但对于其他任务（例如计算图片中的花朵数量）来说可能就不行了。请小心使用。

解决方案

以下是解决方案笔记本。如果您遇到困难，可以使用它。

Keras_Flowers_TPU (solution).ipynb

所学内容

• 🤔 尝试了卷积层
• 🤓 尝试过最大池化、步幅、全局平均池化等
• 😀 在 TPU 上快速迭代了真实世界模型

请花点时间在脑海中过一遍此核对清单。

7. 恭喜！

您已构建了第一个现代卷积神经网络，并将其训练到 80% 以上的准确率，借助 TPU，只需几分钟即可迭代其架构。请继续学习下一个实验，了解现代卷积架构：

• TPU 速度数据流水线：tf.data.Dataset 和 TFRecords
• 您的第一个 Keras 模型，采用迁移学习
• [本实验] 使用 Keras 和 TPU 的卷积神经网络
• 现代卷积神经网络、squeezenet、Xception 以及 Keras 和 TPU

TPU 实践

Cloud AI Platform 提供 TPU 和 GPU：

• 在 Deep Learning VM 上
• 在 AI Platform Notebooks 中
• 在 AI Platform Training 作业中

最后，我们非常欢迎您提供反馈。如果您发现此实验有任何问题，或者认为此实验应进行改进，请告诉我们。您可以通过 GitHub 问题 [反馈链接] 提供反馈。

作者：Martin Görner Twitter：@martin_gorner

www.tensorflow.org