阅读深度学习论文总是很有趣，也很有教育意义，特别是当这些论文和你现在做的项目属于同一领域时更是如此。但是，这些论文包含的架构和解决方案通常很难训练，特别是当你想去尝试他们的方法时，比如说ILSCVR（ImageNet Large Scale Visual Recognition）竞赛中的一些获奖者的方法。我记得我在读VGG16的论文时就在想“这个方法很酷，但是我的GPU跑这个网络时都快挂了。”为了能轻松使用这些网络，Tensorflow 2提供了大量的预训练模型，你可以很快用上它们。而本文，我们将介绍怎样通过一些有名的CNN（Convolutional Neural Network）架构来训练这些论文里介绍的新的神经网络模型。

这时你可能会问“预训练模型是什么？”。本质上来说，预训练模型是之前在大数据集上已经训练好并保存下来的模型，比如说在ImageNet数据集上训练的模型。这些模型可以在tensorflow.keras.applications模块里找到。有两种方式使用这些预训练模型，你可以直接使用它们，或者通过迁移学习使用它们。由于大数据集通常用于某种全局解，所以你可以让预训练模型定制化，使其特别针对性地解决某个特定的问题。通过这个方式，你可以在训练时利用一些最有名的神经网络，不会损失太多的训练时间和计算资源。另外，你可以选定网络里的一些层，修改这些层的行为，实现这些模型的微调。我们在后面的文章里会讲到这一点。

架构

在本文中，我们使用3个预训练模型来解决分类问题的一个例子：VGG16、GoogLeNet（Inception）和ResNet。这每一个架构都赢得了当年的ILSCVR竞赛。2014年，VGG16与GooLeNet有着相同的最好成绩，而ResNet赢得了2015年的竞赛。这些模型是Tensorflow 2中tensorflow.keras.applications模块的一部分。让我们深入探究一下这几个模型。

我们首先看一下VGG16这个架构。它是一个大型的卷积神经网络，由K. Simonyan和A. Zisserman在“Very Deep Convolutional Networks for Large-Scale Image Recognition”这篇论文里提出。这个网络在ImageNet数据集上达到了92.7%的top-5测试精确度。但是，训练这个网络需要好几周。下图是这个模型的高层概览：

VGG16架构

GoogLeNet也被称为Inception，这是因为它使用了两个概念：1x1卷积和Inception模块。第一个概念中，1x1卷积用于降维的模块。通过降维，计算量也会减少，这也就意味着网络的深度和宽度可以增加了。GooLeNet使用了Inception模块，每个卷积层的大小都不相同。

带有降维功能的Inception模块

如图所示，1x1卷积层、3x3卷积层、5x5卷积层和3x3最大池化层操作组合在了一起，然后这些层的运行结果会在输出节点处堆叠在一起。GooLeNet总共有22层，看起来像下面这样：

本文中，我们要使用的最后一个网络架构是残差网络，或者称作ResNet。前面提到的网络的问题在于它们太深了，它们有太多层，导致很难训练（因为梯度消失）。所以，ResNet使用所谓的“identity shortcut connection”（或者称作残差模块）来解决这个问题。

带有降维和不带降维的残差模块

本质上来讲，ResNet沿用了VGG的3x3卷积层的设计，每层卷积后面都有一个Batch Normalization层和ReLu激活函数。但是，差异点在于我们的ResNet在最后一个ReLu前插入了input节点。另一个变种是，输入值（input value）传入了1x1卷积层。

数据集

在本文中，我们使用“Cats vs Dogs”的数据集。这个数据集包含了23,262张猫和狗的图像。

你可能注意到了，这些照片没有归一化，它们的大小是不一样的。但是非常棒的一点是，你可以在Tensorflow Datasets中获取这个数据集。所以，确保你的环境里安装了Tensorflow Dataset。

pip install tensorflow-dataset

和这个库中的其他数据集不同，这个数据集没有划分成训练集和测试集，所以我们需要自己对这两类数据集做个区分。你可以在这里找到这个数据集的更多信息。

实现

这个实现分成了几个部分。首先，我们实现了一个类，其负责载入数据和准备数据。然后，我们导入预训练模型，构建一个类用于修改最顶端的几层网络。最后，我们把训练过程运行起来，并进行评估。当然，在这之前，我们必须导入一些代码库，定义一些全局常量：

import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
import tensorflow_datasets as tfds

IMG_SIZE = 160
BATCH_SIZE = 32
SHUFFLE_SIZE = 1000
IMG_SHAPE = (IMG_SIZE, IMG_SIZE, 3)

好，让我们仔细来看下实现！

数据载入器

这个类负责载入数据和准备数据，用于后续的数据处理。以下是这个类的实现：

class DataLoader(object):
    def __init__(self, image_size, batch_size):
        
        self.image_size = image_size
        self.batch_size = batch_size
        
        # 80% train data, 10% validation data, 10% test data
        split_weights = (8, 1, 1)
        splits = tfds.Split.TRAIN.subsplit(weighted=split_weights)
        
        (self.train_data_raw, self.validation_data_raw, self.test_data_raw), self.metadata = tfds.load(
            'cats_vs_dogs', split=list(splits),
            with_info=True, as_supervised=True)
        
        # Get the number of train examples
        self.num_train_examples = self.metadata.splits['train'].num_examples*80/100
        self.get_label_name = self.metadata.features['label'].int2str
        
        # Pre-process data
        self._prepare_data()
        self._prepare_batches()
        
    # Resize all images to image_size x image_size
    def _prepare_data(self):
        self.train_data = self.train_data_raw.map(self._resize_sample)
        self.validation_data = self.validation_data_raw.map(self._resize_sample)
        self.test_data = self.test_data_raw.map(self._resize_sample)
    
    # Resize one image to image_size x image_size
    def _resize_sample(self, image, label):
        image = tf.cast(image, tf.float32)
        image = (image/127.5) - 1
        image = tf.image.resize(image, (self.image_size, self.image_size))
        return image, label
    
    def _prepare_batches(self):
        self.train_batches = self.train_data.shuffle(1000).batch(self.batch_size)
        self.validation_batches = self.validation_data.batch(self.batch_size)
        self.test_batches = self.test_data.batch(self.batch_size)
   
    # Get defined number of  not processed images
    def get_random_raw_images(self, num_of_images):
        random_train_raw_data = self.train_data_raw.shuffle(1000)
        return random_train_raw_data.take(num_of_images)

这个类实现了很多功能，它实现了很多“public”方法：

_prepare_data：内部方法，用于缩放和归一化数据集里的图像。构造函数需要用到该函数。
_resize_sample：内部方法，用于缩放单张图像。
_prepare_batches：内部方法，用于将图像打包创建为batches。创建train_batches、validation_batches和test_batches，分别用于训练、评估过程。
get_random_raw_images：这个方法用于从原始的、没有经过处理的数据中随机获取固定数量的图像。

但是，这个类的主要功能还是在构造函数中完成的。让我们仔细看看这个类的构造函数。

def __init__(self, image_size, batch_size):

    self.image_size = image_size
    self.batch_size = batch_size

    # 80% train data, 10% validation data, 10% test data
    split_weights = (8, 1, 1)
    splits = tfds.Split.TRAIN.subsplit(weighted=split_weights)

    (self.train_data_raw, self.validation_data_raw, self.test_data_raw), self.metadata = tfds.load(
        'cats_vs_dogs', split=list(splits),
        with_info=True, as_supervised=True)

    # Get the number of train examples
    self.num_train_examples = self.metadata.splits['train'].num_examples*80/100
    self.get_label_name = self.metadata.features['label'].int2str

    # Pre-process data
    self._prepare_data()
    self._prepare_batches()

首先我们通过传入参数定义了图像大小和batch大小。然后，由于该数据集本身没有区分训练集和测试集，我们通过划分权值对数据进行划分。这真是Tensorflow Dataset引入的非常棒的功能，因为我们可以留在Tensorflow生态系统中做这件事，我们不用引入其他的库（比如Pandas或者Scikit Learn）。一旦我们执行了数据划分，我们就开始计算训练样本数量，然后调用辅助函数来为训练准备数据。在这之后，我们需要做的仅仅是实例化这个类的对象，然后载入数据即可。

data_loader = DataLoader(IMG_SIZE, BATCH_SIZE)

plt.figure(figsize=(10, 8))
i = 0
for img, label in data_loader.get_random_raw_images(20):
    plt.subplot(4, 5, i+1)
    plt.imshow(img)
    plt.title("{} - {}".format(data_loader.get_label_name(label), img.shape))
    plt.xticks([])
    plt.yticks([])
    i += 1
plt.tight_layout()
plt.show()

以下是输出结果：

基础模型 & Wrapper

下一个步骤就是载入预训练模型了。我们前面提到过，这些模型位于tensorflow.kearas.applications。我们可以用下面的语句直接载入它们：

vgg16_base = tf.keras.applications.VGG16(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')
googlenet_base = tf.keras.applications.InceptionV3(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')
resnet_base = tf.keras.applications.ResNet101V2(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')

这段代码就是我们创建上述三种网络结构基础模型的方式。注意，每个模型构造函数的include_top参数传入的是false。这意味着这些模型是用于提取特征的。我们一旦创建了这些模型，我们就需要修改这些模型顶部的网络层，使之适用于我们的具体问题。我们使用Wrapper类来完成这个步骤。这个类接收预训练模型，然后添加一个Global Average Polling Layer和一个Dense Layer。本质上，这最后的Dense Layer会用于我们的二分类问题（猫或狗）。Wrapper类把所有这些元素都放到了一起，放在了同一个模型中。

class Wrapper(tf.keras.Model):
    def __init__(self, base_model):
        super(Wrapper, self).__init__()
        
        self.base_model = base_model
        self.average_pooling_layer = tf.keras.layers.GlobalAveragePooling2D()
        self.output_layer = tf.keras.layers.Dense(1)
        
    def call(self, inputs):
        x = self.base_model(inputs)
        x = self.average_pooling_layer(x)
        output = self.output_layer(x)
        return output

然后我们就可以创建Cats vs Dogs分类问题的模型了，并且编译这个模型。

base_learning_rate = 0.0001

vgg16_base.trainable = False
vgg16 = Wrapper(vgg16_base)
vgg16.compile(optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
              loss='binary_crossentropy',
              metrics=['accuracy'])

googlenet_base.trainable = False
googlenet = Wrapper(googlenet_base)
googlenet.compile(optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
              loss='binary_crossentropy',
              metrics=['accuracy'])

resnet_base.trainable = False
resnet = Wrapper(resnet_base)
resnet.compile(optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
              loss='binary_crossentropy',
              metrics=['accuracy'])

注意，我们标记了基础模型是不参与训练的，这意味着在训练过程中，我们只会训练新添加到顶部的网络层，而在网络底部的权重值不会发生变化。

训练

在我们开始整个训练过程之前，让我们思考一下，这些模型的大部头其实已经被训练过了。所以，我们可以执行评估过程来看看评估结果如何：

steps_per_epoch = round(data_loader.num_train_examples)//BATCH_SIZE
validation_steps = 20

loss1, accuracy1 = vgg16.evaluate(data_loader.validation_batches, steps = 20)
loss2, accuracy2 = googlenet.evaluate(data_loader.validation_batches, steps = 20)
loss3, accuracy3 = resnet.evaluate(data_loader.validation_batches, steps = 20)

print("--------VGG16---------")
print("Initial loss: {:.2f}".format(loss1))
print("Initial accuracy: {:.2f}".format(accuracy1))
print("---------------------------")

print("--------GoogLeNet---------")
print("Initial loss: {:.2f}".format(loss2))
print("Initial accuracy: {:.2f}".format(accuracy2))
print("---------------------------")

print("--------ResNet---------")
print("Initial loss: {:.2f}".format(loss3))
print("Initial accuracy: {:.2f}".format(accuracy3))
print("---------------------------")

有意思的是，这些模型在没有预先训练的情况下，我们得到的结果也还过得去（50%的精确度）：

———VGG16———
Initial loss: 5.30
Initial accuracy: 0.51
—————————-

——GoogLeNet—–
Initial loss: 7.21
Initial accuracy: 0.51
—————————-

——–ResNet———
Initial loss: 6.01
Initial accuracy: 0.51
—————————-

把50%作为训练的起点已经挺好的了。所以，就让我们把训练过程跑起来吧，看看我们是否能得到更好的结果。首先，我们训练VGG16：

history = vgg16.fit(data_loader.train_batches,
                    epochs=10,
                    validation_data=data_loader.validation_batches)

训练过程历史数据显示大致如下：

VGG16的训练过程历史数据

然后我们可以训练GoogLeNet。

history = googlenet.fit(data_loader.train_batches,
                    epochs=10,
                    validation_data=data_loader.validation_batches)

这个网络训练过程历史数据如下：

GoogLeNet的训练过程历史数据

最后是ResNet的训练：

history = resnet.fit(data_loader.train_batches,
                    epochs=10,
                    validation_data=data_loader.validation_batches)

以下是ResNet训练过程历史数据如下：

ResNet的训练过程历史数据

由于我们只训练了顶部的几层网络，而不是整个网络，所以训练这三个模型只用了几个小时，而不是几个星期。

评估

我们看到在训练开始前，我们已经有了50%左右的精确度。让我们来看下训练后是什么情况：

loss1, accuracy1 = vgg16.evaluate(data_loader.test_batches, steps = 20)
loss2, accuracy2 = googlenet.evaluate(data_loader.test_batches, steps = 20)
loss3, accuracy3 = resnet.evaluate(data_loader.test_batches, steps = 20)

print("--------VGG16---------")
print("Loss: {:.2f}".format(loss1))
print("Accuracy: {:.2f}".format(accuracy1))
print("---------------------------")

print("--------GoogLeNet---------")
print("Loss: {:.2f}".format(loss2))
print("Accuracy: {:.2f}".format(accuracy2))
print("---------------------------")

print("--------ResNet---------")
print("Loss: {:.2f}".format(loss3))
print("Accuracy: {:.2f}".format(accuracy3))
print("---------------------------")

结果如下：

——–VGG16———
Loss: 0.25
Accuracy: 0.93
—————————

——–GoogLeNet———
Loss: 0.54
Accuracy: 0.95
—————————
——–ResNet———
Loss: 0.40
Accuracy: 0.97
—————————

我们可以看到这三个模型的结果都相当好，其中ResNet效果最好，精确度高达97%。

结论

在本文中，我们演示了怎样使用Tensorflow进行迁移学习。我们创建了一个试验场，在其中可以尝试不同的数据预训练架构，并且在几个小时内就能得到较好的结果。在我们的例子里，我们使用了三个很有名的卷积架构，快速将其修改用于具体的问题。在下篇文章中，我们将微调这些模型，来看看我们是否能得到更好的结果。

原文链接：

https://rubikscode.net/2019/11/11/transfer-learning-with-tensorflow-2/

创作场景

TensorFlow 2.0 迁移学习实践指南