现代卷积神经网络、Squeezenet、Xception 以及 Keras 和 TPU

现代卷积神经网络、Squeezenet、Xception 以及 Keras 和 TPU

关于此 Codelab

subject上次更新时间:10月 4, 2021
account_circleMartin Görner - @martin_gorner 编写

1. 概览

在本实验中,您将了解现代卷积架构,并利用所学知识实现一个名为“squeezenet”的简单而有效的卷积网络。

本实验包含关于卷积神经网络的必要理论解释,非常适合开发者学习深度学习知识。

本实验是“TPU 上的 Keras”的第 4 部分系列视频您可以按以下顺序执行这些操作,也可以单独执行这些操作。

ca8cc21f6838eccc.png

学习内容

  • 要掌握 Keras 函数样式,
  • 使用 squeezenet 架构构建模型
  • 使用 TPU 对您的架构进行快速训练和迭代
  • 使用 tf.data.dataset 实现数据增强
  • 在 TPU 上微调预训练的大型模型 (Xception)

反馈

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

2. Google Colaboratory 快速入门

此实验使用 Google 协作工具,无需您进行任何设置。Colaboratory 是一个用于教学的在线笔记本平台。它提供免费的 CPU、GPU 和 TPU 训练。

688858c21e3beff2

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

c3df49e90e5a654f.png Welcome to Colab.ipynb

选择 TPU 后端

8832c6208c99687d

在 Colab 菜单中,选择运行时 >更改运行时类型,然后选择 TPU。在此 Codelab 中,您将使用一个支持硬件加速训练的强大 TPU(张量处理单元)。首次执行时会自动连接到运行时,您也可以使用“Connect”按钮。

笔记本执行

76d05caa8b4db6da

通过点击单元格并使用 Shift-ENTER 一次执行一个单元格。您还可以使用 Runtime >运行全部

目录

429f106990037ec4

所有笔记本都有一个目录。您可以使用左侧的黑色箭头将其打开。

隐藏单元格

edc3dba45d26f12a.png

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

Authentication

cdd4b41413100543.png

如果您使用已获授权的账号进行身份验证,则 Colab 可以访问您不公开的 Google Cloud Storage 存储分区。上面的代码段将触发身份验证过程。

3. [INFO] 什么是张量处理单元 (TPU)?

简述

f88cf6facfc70166.png

使用 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 以交互速度(每次训练运行的分钟数)构建和优化花卉分类器。

688858c21e3beff2

为什么选择 TPU?

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

8eb3e718b8e2ed08

插图:以矩阵乘法表示的密集神经网络层,通过神经网络同时处理一批 8 张图片。请执行一行 x 列乘法运算,以验证这是否确实对图片的所有像素值进行加权和。卷积层也可以表示为矩阵乘法,尽管它有点复杂( 此处的说明,第 1 部分)。

硬件

MXU 和 VPU

TPU v2 核心由一个矩阵乘法单元 (MXU) 组成,该单元针对所有其他任务(例如激活、softmax 等)运行矩阵乘法和矢量处理单元 (VPU)。VPU 负责处理 float32 和 int32 计算。另一方面,MXU 以混合精度 16-32 位浮点格式运行。

7d68944718f76b18

混合精度浮点数和 bfloat16

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

19c5fc432840c714

神经网络训练通常能够抵抗因浮点精度降低而引入的噪声。在某些情况下,噪声甚至有助于优化器收敛。16 位浮点精度一直以来都用于加快计算速度,但 float16 和 float32 格式却截然不同。将精度从 float32 降低至 float16,通常会导致上溢和下溢。虽然存在解决方案,但通常需要执行额外的操作才能使 float16 正常运行。

因此,Google 在 TPU 中引入了 bfloat16 格式。bfloat16 是截断的 float32,其指数位和范围与 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=16000 个“核心”这通常是不可行的最大的 GPU 大约有 4000 个核心。另一方面,TPU 使用 MXU 中的计算单元的最低要求硬件:仅使用 bfloat16 x bfloat16 => float32 个乘积累加器,没有任何其他用途。这些矩阵非常小,因此 TPU 可以在 128x128 MXU 中实现 16K 并一次性处理此矩阵乘法。

f1b283fc45966717.gif

插图:MXU 收缩阵列。计算元素是乘加累加器。一个矩阵的值被加载到数组中(红点)。另一个矩阵的值流过该数组(灰点)。垂直线会将值向上传播。水平线会传播部分总和。留给用户做练习,以便验证当数据流过数组时,您会得到右侧矩阵乘法的结果。

除此之外,虽然点积是根据 MXU 计算的,但中间求和只是在相邻的计算单元之间流动。它们不需要在内存甚至寄存器文件中存储和检索。最终结果是,在计算矩阵乘法时,TPU 脉动阵列架构具有明显的密度和功率优势,并且在计算矩阵乘法时,也比 GPU 具有明显的速度优势。

Cloud TPU

当您请求一个“Cloud TPU v2"在 Google Cloud Platform 上,您会得到一个配有 PCI 连接 TPU 板的虚拟机 (VM)。TPU 板有四个双核 TPU 芯片。每个 TPU 核心都有一个 VPU(矢量处理单元)和 128x128 MXU(矩阵乘法单元)。这个“Cloud TPU”通常通过网络连接到请求它的虚拟机。因此,整个过程如下所示:

dfce5522ed644ece.png

图解:具有网络连接的“Cloud TPU”的虚拟机加速器"Cloud TPU"它由一个虚拟机组成,虚拟机配有 PCI 连接的 TPU 板,板上装有四个双核 TPU 芯片。

TPU Pod

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

2ec1e0d341e7fc34.jpeg

图解:TPU v3 Pod。通过 HPC 互连连接的 TPU 板和机架。

在训练期间,梯度通过全归约算法在 TPU 核心之间交换(此处充分说明了全归约)。正在训练的模型可以通过使用大批量大小进行训练来充分利用硬件。

d97b9cc5d40fdb1d.gif

图解:在 Google TPU 的二维环形网状网 HPC 网络上使用全约化算法在训练期间同步梯度。

软件

大批量训练

理想的 TPU 批次大小是每个 TPU 核心 128 个数据项,但硬件已经可以显示出每个 TPU 核心 8 个数据项的良好利用率。请注意,一个 Cloud TPU 有 8 个核心。

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

da534407825f01e3.png

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

幕后探秘:XLA

TensorFlow 程序定义计算图。TPU 不会直接运行 Python 代码,而是运行由 Tensorflow 程序定义的计算图。在后台,一个名为 XLA(加速线性代数编译器)的编译器将计算节点的 Tensorflow 图转换为 TPU 机器代码。此编译器还可以对您的代码和内存布局执行许多高级优化。编译会在工作发送到 TPU 时自动进行。您无需在 build 链中明确包含 XLA。

edce61112cd57972.png

图解:为了在 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 env。变量或者使用显式参数 TPUClusterResolver(tp_uname, zone, project) 调用 TPUClusterResolver
  • TPUStrategy 是实现分布和“all-reduce”的部分梯度同步算法。
  • 系统会通过范围应用策略。必须在策略 scope() 中定义模型。
  • 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. [INFO] 神经网络分类器 101

简述

如果你已经知道下一段落中以粗体显示的所有术语,可以接着进行下一个练习。如果您刚开始接触深度学习,欢迎继续阅读。

对于构建为一系列层的模型,Keras 可提供 Sequential API。例如,使用 3 个密集层的图片分类器可以在 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, ... )

688858c21e3beff2

密集神经网络

这是最简单的图像分类神经网络。它由“神经元”组成并层层叠放在一起。第一层处理输入数据,并将其输出馈送到其他层。称为“密集”因为每个神经元都与前一层中的所有神经元相连。

c21bae6dade487bc.png

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

神经元、激活、RELU

一个“神经元”计算所有输入的加权和,然后添加一个名为“偏差”的值并通过所谓的“激活函数”提供结果。权重和偏差最初是未知的。它们会随机初始化并“学习”通过使用大量已知数据训练神经网络来实现。

644f4213a4ee70e5

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

Softmax 激活

上述网络以 5 神经元层结尾,因为我们将花卉分为 5 类(玫瑰、郁金香、蒲公英、雏菊、向日葵)。中间层的神经元使用经典的 RELU 激活函数进行激活。不过,在最后一层中,我们需要计算 0 到 1 之间的数字,表示这朵花是玫瑰、郁金香等的概率。为此,我们将使用一个名为“softmax”的激活函数。

对向量应用 Softmax 的方法是取每个元素的指数,然后对向量进行归一化,通常使用 L1 范数(绝对值总和),使值加起来为 1,并且可以解释为概率。

ef0d98c0952c262d.png d51252f75894479e.gif

交叉熵损失

现在,我们的神经网络可以根据输入图片生成预测,接下来我们需要衡量预测的好坏,即网络告诉我们的信息与正确答案之间的距离,通常称为“标签”。请记住,数据集中的所有图片都有正确的标签。

任何距离都有效,但对于分类问题而言,所谓的“交叉熵距离”是最有效的。我们将这种情况称为错误或“损失”。函数:

7bdf8753d20617fb.png

梯度下降法

“训练”神经网络实际上意味着使用训练图片和标签来调整权重和偏差,以便最大限度地降低交叉熵损失函数的值。其运作方式如下。

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

如果我们计算交叉熵相对于所有权重和所有偏置的偏导数,就会得到一个“梯度”,该梯度针对给定图像、标签以及权重和偏差的现值进行了计算。请记住,我们可以有数百万个权重和偏差,因此计算梯度声就像是大量的工作。幸运的是,Tensorflow 可以为我们做到这一点。渐变的数学属性是它指向“向上”。由于我们想去交叉熵较低的地方,因此会前往相反的方向。我们以梯度的分数更新权重和偏差。然后,我们在训练循环中使用下一批训练图片和标签重复执行相同的操作。我们希望这可以收敛到交叉熵极低的位置,但无法保证此最小值是唯一的。

梯度下降法 2.png

小批量和动量

您可以仅对一张样本图片计算梯度,并立即更新权重和偏差,但对一批 128 张图片(例如 128 张图片)执行此操作将产生一个梯度,该梯度可以更好地表示不同样本图片施加的限制,因此可能会更快地收敛于解决方案。小批次的大小是一个可调整的参数。

这种技术有时称为“随机梯度下降”还有一个更实际的好处:使用批量处理还意味着使用较大的矩阵,这些矩阵通常更易于在 GPU 和 TPU 上进行优化。

不过,收敛可能仍然有点混乱,即使梯度矢量都为零,收敛也可能会停止。这是否意味着我们找到了一个最低值?不一定。梯度分量可以为零的最小值或最大值。对于包含数百万个元素的梯度矢量,如果这些元素全部为零,则每个零对应于一个最小值而没有一个对应于最大点的概率非常小。在具有很多维度的空间中,马鞍点很常见,我们不想就此止步。

52e824fe4716c4a0

插图:马鞍点。梯度为 0,但并非在所有方向上的最小值。(图片出处 维基媒体:Nicoguaro - 自创内容,CC BY 3.0

解决方法是为优化算法增加一些动力,使其不停地驶过马鞍点。

术语库

batchmini-batch:始终对批量训练数据和标签执行训练。这样做有助于算法收敛。“批次”维度通常是数据张量的第一个维度。例如,形状为 [100, 192, 192, 3] 的张量包含 100 张 192x192 像素的图片,每个像素有三个值 (RGB)。

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

密集层:一个神经元层,其中每个神经元都与前一层中的所有神经元连接。

特征:神经网络的输入有时称为“特征”。弄清楚将数据集的哪些部分(或部分组合)馈送到神经网络以获得良好预测结果的过程称为“特征工程”。

labels:“类”的另一种名称在监督式分类问题中,

学习速率:权重和偏差在训练循环的每次迭代中更新时的梯度百分比。

logits:在应用激活函数之前,一层神经元的输出称为“logits”。这个术语来自“逻辑函数”也称为“S 型函数”这曾是最常用的激活函数。"逻辑函数之前的中子输出"已简化为“logits”。

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

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

独热编码:第 3 类(共 5 类)编码为 5 个元素(第三个元素为 1 除外)的向量。

relu:修正的线性单元。一种热门的神经元激活函数。

S 型函数:另一种过去很流行的激活函数,在特殊情况下仍然有用。

softmax:一个作用于向量的特殊激活函数,用于增大最大分量与所有其他分量之间的差值,同时对该向量进行归一化,使其总和为 1,以便将其解释为概率向量。用作分类器中的最后一步。

tensor:“张量”类似于矩阵,但维度数量没有限制。一维张量是一个向量。二维张量就是一个矩阵。然后,您可以得到具有 3 个、4 个、5 个或更多维度的张量。

5. [INFO] 卷积神经网络

简述

如果你已经知道下一段落中以粗体显示的所有术语,可以接着进行下一个练习。如果您刚开始接触卷积神经网络,请继续阅读。

convolutional.gif

插图:使用两个由 4x4x3=48 个可学习权重组成的连续过滤器来过滤图片。

下面是简单的卷积神经网络在 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'])

688858c21e3beff2

卷积神经网络基础知识

在卷积网络中的一个层中,一个“神经元”会对紧邻其上的像素进行加权和,只对其上的一小块区域进行加权。它会添加偏差并通过激活函数向和馈送总和,就像常规密集层中的神经元一样。然后,使用相同的权重对整张图片重复此操作。请记住,在密集层中,每个神经元都有自己的权重。在这里,一个“补丁”的权重在图像上两个方向滑动(“卷积”)。输出的值与图像中的像素数一样多(不过边缘部分需要一些内边距)。这是一个使用 4x4x3=48 权重的过滤器的过滤操作。

但是,48 个权重并不够。为了增加自由度,我们使用一组新权重重复同一操作。这样会生成一组新的过滤器输出。我们称之为“频道”通过与输入图像中的 R、G、B 通道类比来比较输出结果。

屏幕截图,2016 年 7 月 29 日 16.02.37.png

通过添加新维度,将两组(或更多)权重求和为一个张量。这为我们确定了卷积层权重张量的通用形状。由于输入和输出通道的数量是参数,因此我们可以开始堆叠和链接卷积层。

d1b557707bcd1cb9.png

图解:卷积神经网络转换“立方体”将数据转移到其他“立方体”数据。

步进卷积、最大池化

通过以步长 2 或 3 执行卷积,我们还可以在水平维度上缩小生成的数据立方体。您可以采用以下两种常见方式:

  • 步进卷积:如上所示的滑动过滤器,但步长 >1
  • 最大池化:应用 MAX 操作的滑动窗口(通常采用 2x2 图块,每 2 像素重复一次)

2b2d4263bb8470b.gif

图解:将计算窗口滑动 3 个像素会减少输出值。步长卷积或最大池化(以 2x2 窗口的步长 2 滑动的最大值)是在水平维度上缩小数据立方体的方法。

卷积分类器

最后,我们通过展平最后一个数据立方体并通过密集的 softmax 激活层馈送分类头来附加分类头。典型的卷积分类器可能如下所示:

4a61aaffb6cba3d1

插图:使用卷积层和 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'])

6. [NEW INFO] 现代卷积架构

简述

7968830b57b708c0

插图:卷积“模块”。这时什么方法最好?一个最大池层后跟一个 1x1 卷积层,还是不同的层组合?尝试所有这些方法,将结果串联起来,然后让网络决定。右侧:“inception”使用此类模块的卷积架构。

在 Keras 中,要创建数据流可以进出分支的模型,您必须使用“函数”模型样式。示例如下:

l = tf.keras.layers # syntax shortcut

y
= l.Conv2D(filters=32, kernel_size=3, padding='same',
             activation
='relu', input_shape=[192, 192, 3])(x) # x=input image

# module start: branch out
y1
= l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3
= l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y
= l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation

# many more layers ...

# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z
= l.Dense(5, activation='softmax')(y)
model
= tf.keras.Model(x, z)

688858c21e3beff2

其他低成本技巧

3x3 小滤镜

40a7b15fb7dbe75c

在此图中,您可以看到两个连续的 3x3 过滤器的结果。尝试追溯是哪些数据点导致了结果:这两个连续的 3x3 过滤器计算 5x5 区域的某种组合。这与 5x5 过滤器计算的组合并不完全相同,但值得尝试,因为两个连续的 3x3 过滤器比单个 5x5 过滤器便宜。

1x1 卷积?

fd7cac16f8ecb423.png

用数学术语来说,“1x1”卷积是乘以一个常数,并不是一个非常有用的概念。但在卷积神经网络中,请记住,滤波器应用于数据立方体,而不仅仅是 2D 图像。因此,“1x1”过滤器会计算 1x1 数据列(见图)的加权和,当您在数据中滑动它时,您将得到输入渠道的线性组合。这真的很有用。如果将声道视为各个过滤操作的结果,例如针对“尖耳”的过滤器,或针对“胡须”的另一个过滤器第三种是“斜眼”然后是“1x1”卷积层将计算这些特征的多个可能的线性组合,这在寻找“猫”时可能很有用。除此之外,1x1 层使用的权重也更少。

7. 挤压式洗衣机

“Squeezenet”一文中展示了一种综合运用上述理念的简单方法。论文。作者提出了一种非常简单的卷积模块设计,仅使用 1x1 和 3x3 卷积层。

1730ac375379269b

图解:基于“fire modules”的 squeezenet 架构。它们会交替“挤压”垂直维度中的传入数据,后跟两个“展开”的并行 1x1 和 3x3 卷积层数据深度。

动手实践

继续上一个笔记本,构建一个受 squeezenet 启发的卷积神经网络。您必须将模型代码更改为 Keras“函数样式”。

c3df49e90e5a654f.png Keras_Flowers_TPU (playground).ipynb

其他信息

在本练习中为 squeezenet 模块定义一个辅助函数会很有用:

def fire(x, squeeze, expand):
  y
= l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
  y1
= l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
  y3
= l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
 
return tf.keras.layers.concatenate([y1, y3])

# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
 
return lambda x: fire(x, squeeze, expand)

# usage:
x
= l.Input(shape=[192, 192, 3])
y
= fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y
= fire_module(squeeze=32, expand=64)(y)
...
model
= tf.keras.Model(x, y)

这次的目标是达到 80% 的准确率。

可以尝试的操作

先从单个卷积层开始,然后使用“fire_modules”与 MaxPooling2D(pool_size=2) 层交替使用。您可以在网络中尝试最多 2 到 4 个池化层,也可以在最大池化层之间使用 1、2 或 3 个连续触发模块。

在触发模块中,“握压”参数通常应小于“expand”参数。这些参数实际上是过滤器的数量。通常,范围为 8 至 196。您可以采用过滤器数量通过网络逐渐增加的架构,也可以尝试所有触发模块具有相同数量的过滤器的简单架构。

示例如下:

x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB

y
= tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y
= fire_module(24, 48)(y)
y
= tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y
= fire_module(24, 48)(y)
y
= tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y
= fire_module(24, 48)(y)
y
= tf.keras.layers.GlobalAveragePooling2D()(y)
y
= tf.keras.layers.Dense(5, activation='softmax')(y)

model
= tf.keras.Model(x, y)

此时,您可能会注意到,您的实验进展不顺利,80% 的准确率目标似乎偏远。是时候试试其他低成本技巧了。

批量归一化

批次归一化有助于解决你遇到的收敛问题。我们将在下一次研讨会中对这一技术进行详细说明。目前,请将其视为黑盒子“魔法”帮助程序,在您的网络中的每个卷积层之后添加以下代码行,包括 fire_module 函数内的层:

y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context

由于我们的数据集很小,因此动量参数必须从默认值 0.99 降到 0.9。暂时不用考虑这个细节。

数据增强

通过利用简单的转换(例如饱和度变化的左右翻转)来增强数据,您可以获得更高的百分点:

4ed2958e09b487ca

ad795b70334e0d6b.png

使用 tf.data.Dataset API 在 Tensorflow 中可以非常轻松地做到这一点。为数据定义一个新的转换函数:

def data_augment(image, label):
    image
= tf.image.random_flip_left_right(image)
    image
= tf.image.random_saturation(image, lower=0, upper=2)
   
return image, label

然后,将其用于最终的数据转换(“训练和验证数据集”单元格,函数“get_batched_dataset”):

dataset = dataset.repeat() # existing line
# insert this
if augment_data:
  dataset
= dataset.map(data_augment, num_parallel_calls=AUTO)
dataset
= dataset.shuffle(2048) # existing line

不要忘记将数据增强设置为可选,并添加必要的代码以确保只增强训练数据集。扩充验证数据集毫无意义。

35 个周期内 80% 的准确率现在都触手可及了。

解决方案

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

c3df49e90e5a654f.png Keras_Flowers_TPU_squeezenet.ipynb

所学内容

  • 🥰? Keras 的“函数样式”模型
  • 🤓? Squeezenet 架构
  • 🤓? 使用 tf.data.datset 进行数据增强

请花点时间回想一下这份核对清单。

8. Xception 微调

可分离卷积

最近,一种实现卷积层的其他方式越来越受欢迎:可分离深度的卷积。我知道这听起来很令人吃惊,但概念其实很简单。它们在 TensorFlow 和 Keras 中以 tf.keras.layers.SeparableConv2D 的形式实现。

可分离卷积也会对图片运行过滤器,但会对输入图片的每个通道使用一组不同的权重。后跟“1x1 卷积”,也就是一系列点积,用于生成已过滤通道的加权总和。每次使用新的权重时,可根据需要计算任意数量的通道加权重组。

615720b803bf8dda.gif

插图:可分离的卷积。阶段 1:每个通道具有单独过滤器的卷积。第 2 阶段:渠道的线性重组。使用一组新的权重重复操作,直到达到所需的输出通道数量。第 1 阶段也可以重复,每次都使用新的权重,但在实践中很少会这样做。

可分离卷积用于最新的卷积网络架构:MobileNetV2、Xception、EfficientNet。顺便提一下,你之前用于迁移学习的 MobileNetV2 就是这个。

它们比常规卷积更便宜,并且已被发现在实践中同样有效。以下是上图示例的权重计数:

卷积层:4 x 4 x 3 x 5 = 240

可分离的卷积层:4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

它作为练习留给读者进行计算,计算应用各卷积层样式所需的乘法次数以类似的方式进行扩缩。可分离卷积更小,计算效率更高。

动手实践

从“迁移学习”重新开始Playground 笔记本,但这次选择 Xception 作为预训练模型。Xception 仅使用可分离的卷积。让所有权重保持可训练。我们将对数据微调预训练权重,而不是像这样使用预训练层。

c3df49e90e5a654f.png Keras Flowers transfer learning (playground).ipynb

目标:准确率 >95%(不,说真的,这是有可能的!)

这是最后一个练习,需要编写更多代码和数据科学工作。

有关微调的其他信息

Xception 可用于 tf.keras.application 中的标准预训练模型。*这次别忘了让所有权重保持可训练。

pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
                                                  include_top
=False)
pretrained_model
.trainable = True

为了在微调模型时获得良好的结果,您需要注意学习速率,并使用具有磨合期的学习速率计划。示例如下:

9b1af213b2b36d47

从标准学习速率入手会破坏模型的预训练权重。开始时会逐步保留这些数据,直到模型能够根据数据进行合理修改。完成斜坡后,您可以使用恒定或指数衰减的学习速率继续学习。

在 Keras 中,学习速率通过回调指定,您可以在该回调中为每个周期计算适当的学习速率。Keras 会针对每个周期将正确的学习速率传递给优化器。

def lr_fn(epoch):
  lr = ...
  return lr

lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)

model.fit(..., callbacks=[lr_callback])

解决方案

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

c3df49e90e5a654f.png 07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

所学内容

  • 🤔? 可分离深度的卷积
  • 🤓? 学习速率时间表
  • 😈? 对预训练模型进行微调。

请花点时间回想一下这份核对清单。

9. 恭喜!

您已经构建了自己的第一个现代卷积神经网络,训练后准确率达到 90% 以上。得益于 TPU,您可以在几分钟内对连续训练进行迭代。4 个“在 TPU 上使用 Keras”Codelab 到此结束:

TPU 使用实例

Cloud AI Platform 上提供 TPU 和 GPU:

最后,欢迎您提供反馈。如果您发现此实验中存在错误,或者您认为需要改进,请告诉我们。您可以通过 GitHub 问题 [反馈链接] 提供反馈。

HR.png

马丁·戈尔纳 ID small.jpg
作者:Martin Görner
Twitter:@martin_gorner

TensorFlow 徽标.jpg
www.tensorflow.org