“很少的”样本可能是几百张图像，也可能是几万张图像。来看一个实例，我们将重点讨论猫狗图像分类，数据集中包含 4000 张猫和狗的图像（ 2000 张猫的图像， 2000 张狗的图像）。我们将 2000 张图像用于训练， 1000 张用于验证， 1000 张用于测试。

Section 1 将介绍解决这一问题的基本策略，即使用已有的少量数据从头开始训练一个新模型。
Section 2 会介绍将深度学习应用于小型数据集的另外两个重要技巧： 用预训练的网络做特征提取（得到的精度范围在 90%~96%）， 对预训练的网络进行微调（最终精度为 97%）。
总而言之，这三种策略——从头开始训练一个小型模型、使用预训练的网络做特征提取、对预训练的网络进行微调——构成了你的工具箱，未来可用于解决小型数据集的图像分类问题。

Section 1 在小型数据集上从头开始训练一个 CNN

思路：首先，在 2000 个训练样本上训练一个简单的小型卷积神经网络，不做任何正则化，为模型目标设定一个基准。这会得到 71% 的分类精度。此时主要的问题在于过拟合。然后，我们会介绍数据增强（ data augmentation），它在计算机视觉领域是一种非常强大的降低过拟合的技术。使用数据增强之后，网络精度将提高到 82%。

深度学习与小数据问题的相关性： 深度学习的一个基本特性就是能够独立地在训练数据中找到有趣的特征，无须人为的特征工程，而这
只在拥有大量训练样本时才能实现。对于输入样本的维度非常高（比如图像）的问题尤其如此。 但对于初学者来说，所谓“大量”样本是相对的，即相对于你所要训练网络的大小和深度而言。只用几十个样本训练卷积神经网络就解决一个复杂问题是不可能的，但如果模型很小，并做了很好的正则化，同时任务非常简单，那么几百个样本可能就足够了。由于卷积神经网络学到的是局部的、平移不变的特征，它对于感知问题可以高效地利用数据。虽然数据相对较少，但在非常小的图像数据集上从头开始训练一个卷积神经网络，仍然可以得到不错的结果，而且无须任何自定义的特征工程。 此外，深度学习模型本质上具有高度的可复用性，比如，已有一个在大规模数据集上训练的图像分类模型或语音转文本模型，你只需做很小的修改就能将其复用于完全不同的问题。特别是在计算机视觉领域，许多预训练的模型（通常都是在 ImageNet 数据集上训练得到的）现在都可以公开下载，并可以用于在数据很少的情况下构建强大的视觉模型。

1. 下载数据

本节用到的猫狗分类数据集不包含在 Keras 中。它由 Kaggle 在 2013 年末公开并作为一项计算视觉竞赛的一部分， 可以从 https://www.kaggle.com/c/dogs-vs-cats/data 下载原始数据集。或者在下面百度网盘中下载：

数据集采用 Kaggle 中的猫狗图片数据集： 链接：https://pan.baidu.com/s/1CnfrQlcAB8gJe0PzqNndNw 提取码：f1wr

这些图像都是中等分辨率的彩色 JPEG 图像：
image.png
这个数据集包含 25 000 张猫狗图像（每个类别都有 12 500 张），大小为 543MB（压缩后）。下载数据并解压之后，你需要创建一个新数据集，其中包含三个子集：每个类别各 1000 个样本的训练集、每个类别各 500 个样本的验证集和每个类别各 500 个样本的测试集。

创建新数据集的代码如下：

  1. original_dataset_dir = r'E:\datasets\kaggle\dogs-and-cats\train\train'
  3. # The directory where we will
  4. # store our smaller dataset
  5. base_dir = r'.\cats_and_dogs_small'
  6. os.mkdir(base_dir)
  8. # Directories for our training,
  9. # validation and test splits
  10. train_dir = os.path.join(base_dir, 'train')
  11. os.mkdir(train_dir)
  12. validation_dir = os.path.join(base_dir, 'validation')
  13. os.mkdir(validation_dir)
  14. test_dir = os.path.join(base_dir, 'test')
  15. os.mkdir(test_dir)
  17. # Directory with our training cat pictures
  18. train_cats_dir = os.path.join(train_dir, 'cats')
  19. os.mkdir(train_cats_dir)
  21. # Directory with our training dog pictures
  22. train_dogs_dir = os.path.join(train_dir, 'dogs')
  23. os.mkdir(train_dogs_dir)
  25. # Directory with our validation cat pictures
  26. validation_cats_dir = os.path.join(validation_dir, 'cats')
  27. os.mkdir(validation_cats_dir)
  29. # Directory with our validation dog pictures
  30. validation_dogs_dir = os.path.join(validation_dir, 'dogs')
  31. os.mkdir(validation_dogs_dir)
  33. # Directory with our validation cat pictures
  34. test_cats_dir = os.path.join(test_dir, 'cats')
  35. os.mkdir(test_cats_dir)
  37. # Directory with our validation dog pictures
  38. test_dogs_dir = os.path.join(test_dir, 'dogs')
  39. os.mkdir(test_dogs_dir)
  41. # Copy first 1000 cat images to train_cats_dir
  42. fnames = ['cat.{}.jpg'.format(i) for i in range(1000)]
  43. for fname in fnames:
  44.     src = os.path.join(original_dataset_dir, fname)
  45.     dst = os.path.join(train_cats_dir, fname)
  46.     shutil.copyfile(src, dst)
  48. # Copy next 500 cat images to validation_cats_dir
  49. fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)]
  50. for fname in fnames:
  51.     src = os.path.join(original_dataset_dir, fname)
  52.     dst = os.path.join(validation_cats_dir, fname)
  53.     shutil.copyfile(src, dst)
  55. # Copy next 500 cat images to test_cats_dir
  56. fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)]
  57. for fname in fnames:
  58.     src = os.path.join(original_dataset_dir, fname)
  59.     dst = os.path.join(test_cats_dir, fname)
  60.     shutil.copyfile(src, dst)
  62. # Copy first 1000 dog images to train_dogs_dir
  63. fnames = ['dog.{}.jpg'.format(i) for i in range(1000)]
  64. for fname in fnames:
  65.     src = os.path.join(original_dataset_dir, fname)
  66.     dst = os.path.join(train_dogs_dir, fname)
  67.     shutil.copyfile(src, dst)
  69. # Copy next 500 dog images to validation_dogs_dir
  70. fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)]
  71. for fname in fnames:
  72.     src = os.path.join(original_dataset_dir, fname)
  73.     dst = os.path.join(validation_dogs_dir, fname)
  74.     shutil.copyfile(src, dst)
  76. # Copy next 500 dog images to test_dogs_dir
  77. fnames = ['dog.{}.jpg'.format(i) for i in range(1500, 2000)]
  78. for fname in fnames:
  79.     src = os.path.join(original_dataset_dir, fname)
  80.     dst = os.path.join(test_dogs_dir, fname)
  81.     shutil.copyfile(src, dst)

完成后我们会有 2000 张训练图像、 1000 张验证图像和 1000 张测试图像。每个分组中两个类别的样本数相同，这是一个平衡的二分类问题，分类精度可作为衡量成功的指标。

2. 构建网络

构建思路：在前一个 MNIST 示例中，我们构建了一个小型卷积神经网络，所以你应该已经熟悉这种网络。我们将复用相同的总体结构，即卷积神经网络由 Conv2D 层（使用 relu 激活）和MaxPooling2D 层交替堆叠构成。但由于这里要处理的是更大的图像和更复杂的问题，你需要相应地增大网络，即再增加一个 Conv2D+MaxPooling2D 的组合。这既可以增大网络容量，也可以进一步减小特征图的尺寸，使其在连接 Flatten 层时尺寸不会太大。本例中初始输入的尺寸为 150× 150（有些随意的选择），所以最后在 Flatten 层之前的特征图大小为 7× 7。

注意： 网络中特征图的深度在逐渐增大（从 32 增大到 128），而特征图的尺寸在逐渐减小（从150× 150 减小到 7× 7）。这几乎是所有卷积神经网络的模式。

你面对的是一个二分类问题，所以网络最后一层是使用 sigmoid 激活的单一单元（大小为1 的 Dense 层）。这个单元将对某个类别的概率进行编码。

  1. from keras import layers
  2. from keras import models
  4. model = models.Sequential()
  5. model.add(layers.Conv2D(32, (3, 3), activation='relu',
  6.                         input_shape=(150, 150, 3)))
  7. model.add(layers.MaxPooling2D((2, 2)))
  8. model.add(layers.Conv2D(64, (3, 3), activation='relu'))
  9. model.add(layers.MaxPooling2D((2, 2)))
  10. model.add(layers.Conv2D(128, (3, 3), activation='relu'))
  11. model.add(layers.MaxPooling2D((2, 2)))
  12. model.add(layers.Conv2D(128, (3, 3), activation='relu'))
  13. model.add(layers.MaxPooling2D((2, 2)))
  14. model.add(layers.Flatten())
  15. model.add(layers.Dense(512, activation='relu'))
  16. model.add(layers.Dense(1, activation='sigmoid'))

在编译这一步，和前面一样，我们将使用 RMSprop 优化器。因为网络最后一层是单一 sigmoid 单元，所以我们将使用二元交叉熵作为损失函数。

  1. from keras import optimizers
  3. model.compile(loss='binary_crossentropy',
  4.               optimizer=optimizers.RMSprop(lr=1e-4),
  5. metrics=['acc'])

3. 数据预处理

将数据输入神经网络之前，应该将数据格式化为经过预处理的浮点数张量。现在，数据以 JPEG 文件的形式保存在硬盘中，所以数据预处理步骤大致如下：

  1. 读取图像文件。
  2. 将 JPEG 文件解码为 RGB 像素网格。
  3. 将这些像素网格转换为浮点数张量。
  4. 将像素值（ 0~255 范围内）缩放到 [0, 1] 区间（正如你所知，神经网络喜欢处理较小的输入值）。

幸运的是， Keras 拥有自动完成这些步骤的工具。 Keras有一个图像处理辅助工具的模块，位于 keras.preprocessing.image。特别地，它包含ImageDataGenerator类，可以快速创建 Python 生成器，能够将硬盘上的图像文件自动转换为预处理好的张量批量。 

  1. from keras.preprocessing.image import ImageDataGenerator
  3. # All images will be rescaled by 1./255
  4. train_datagen = ImageDataGenerator(rescale=1./255)
  5. test_datagen = ImageDataGenerator(rescale=1./255)
  7. train_generator = train_datagen.flow_from_directory(
  8.         train_dir,  # This is the target directory
  9.         target_size=(150, 150),  # All images will be resized to 150x150
  10.         batch_size=20,
  11.         class_mode='binary')  # Since we use binary_crossentropy loss, we need binary labels
  13. validation_generator = test_datagen.flow_from_directory(
  14.         validation_dir,
  15.         target_size=(150, 150),
  16.         batch_size=20,
  17.         class_mode='binary')

我们来看一下其中一个生成器的输出：它生成了 150× 150 的 RGB 图像［形状为 (20, 150, 150, 3)］与二进制标签［形状为 (20, )］组成的批量。每个批量中包含 20 个样本（批量大小）。注意，生成器会不停地生成这些批量，它会不断循环目标文件夹中的图像。因此，你需要在某个时刻终止（ break）迭代循环 。

拟合模型的代码：

  1. history = model.fit_generator(
  2.       train_generator,   # 训练数据的生成器
  3.       steps_per_epoch=100,   # 从生成器中抽取 steps_per_epoch 个批量后（即运行了 steps_per_epoch 次梯度下降），拟合过程将进入下一个轮次。
  4.       epochs=30,  
  5.       validation_data=validation_generator,
  6.       validation_steps=50)  # 说明需要从验证生成器中抽取多少个批次用于评估。

始终在训练完成后保存模型，这是一种良好实践：

  1. model.save('cats_and_dogs_small_1.h5')

我们来分别绘制训练过程中模型在训练数据和验证数据上的损失和精度:

  1. import matplotlib.pyplot as plt
  3. acc = history.history['acc']
  4. val_acc = history.history['val_acc']
  5. loss = history.history['loss']
  6. val_loss = history.history['val_loss']
  8. epochs = range(len(acc))
  10. plt.plot(epochs, acc, 'bo', label='Training acc')
  11. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  12. plt.title('Training and validation accuracy')
  13. plt.legend()
  15. plt.figure()
  17. plt.plot(epochs, loss, 'bo', label='Training loss')
  18. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  19. plt.title('Training and validation loss')
  20. plt.legend()
  22. plt.show()

image.pngimage.png

从这些图像中都能看出过拟合的特征。训练精度随着时间线性增加，直到接近 100%，而验证精度则停留在 70%~72%。验证损失仅在 5 轮后就达到最小值，然后保持不变，而训练损失则一直线性下降，直到接近于 0。

因为训练样本相对较少（ 2000 个），所以过拟合是你最关心的问题。 前面已经介绍过几种降低过拟合的技巧，比如 dropout 和权重衰减（ L2 正则化）。现在我们将使用一种针对于计算机视觉领域的新方法，在用深度学习模型处理图像时几乎都会用到这种方法，它就是数据增强（ data augmentation）

4. 使用数据增强（data augmentation）

过拟合的原因是学习样本太少，导致无法训练出能够泛化到新数据的模型。如果拥有无限的数据，那么模型能够观察到数据分布的所有内容，这样就永远不会过拟合。数据增强是从现有的训练样本中生成更多的训练数据，其方法是利用多种能够生成可信图像的随机变换来**增加（ augment**）样本。其目标是，模型在训练时不会两次查看完全相同的图像。这让模型能够观察到数据的更多内容，从而具有更好的泛化能力。

在 Keras 中，这可以通过对 ImageDataGenerator 实例读取的图像执行多次随机变换来实现：

  1. datagen = ImageDataGenerator(
  2.       rotation_range=40,
  3.       width_shift_range=0.2,
  4.       height_shift_range=0.2,
  5.       shear_range=0.2,
  6.       zoom_range=0.2,
  7.       horizontal_flip=True,
  8.       fill_mode='nearest')

这里只选择了几个参数（想了解更多参数，请查阅 Keras 文档）。我们来快速介绍一下这些参数的含义。

  • rotation_range 是角度值（在 0~180 范围内），表示图像随机旋转的角度范围。
  • width_shift 和 height_shift 是图像在水平或垂直方向上平移的范围（相对于总宽度或总高度的比例）。
  • shear_range 是随机错切变换的角度。‰ zoom_range 是图像随机缩放的范围。
  • horizontal_flip 是随机将一半图像水平翻转。如果没有水平不对称的假设（比如真实世界的图像），这种做法是有意义的。
  • fill_mode 是用于填充新创建像素的方法，这些新像素可能来自于旋转或宽度/高度平移。

我们来看一下增强后的图像 :
image.png

  1. # 显示几个随机增强后的训练图像
  2. from keras.preprocessing import image
  4. fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]
  6. # We pick one image to "augment"
  7. img_path = fnames[3]
  9. # Read the image and resize it
  10. img = image.load_img(img_path, target_size=(150, 150))
  12. # Convert it to a Numpy array with shape (150, 150, 3)
  13. x = image.img_to_array(img)
  15. # Reshape it to (1, 150, 150, 3)
  16. x = x.reshape((1,) + x.shape)
  18. # The .flow() command below generates batches of randomly transformed images.
  19. # It will loop indefinitely, so we need to `break` the loop at some point!
  20. i = 0
  21. for batch in datagen.flow(x, batch_size=1):
  22.     plt.figure(i)
  23.     imgplot = plt.imshow(image.array_to_img(batch[0]))
  24.     i += 1
  25.     if i % 4 == 0:
  26.         break
  28. plt.show()

如果你使用这种数据增强来训练一个新网络，那么网络将不会两次看到同样的输入。但网络看到的输入仍然是高度相关的，因为这些输入都来自于少量的原始图像。你无法生成新信息，而只能混合现有信息。因此，这种方法可能不足以完全消除过拟合。
为了进一步降低过拟合，你还需要向模型中添加一个 Dropout 层，添加到密集连接分类器之前。

  1. # 定义一个包含 dropout 的新卷积神经网络
  2. model = models.Sequential()
  3. model.add(layers.Conv2D(32, (3, 3), activation='relu',
  4.                         input_shape=(150, 150, 3)))
  5. model.add(layers.MaxPooling2D((2, 2)))
  6. model.add(layers.Conv2D(64, (3, 3), activation='relu'))
  7. model.add(layers.MaxPooling2D((2, 2)))
  8. model.add(layers.Conv2D(128, (3, 3), activation='relu'))
  9. model.add(layers.MaxPooling2D((2, 2)))
  10. model.add(layers.Conv2D(128, (3, 3), activation='relu'))
  11. model.add(layers.MaxPooling2D((2, 2)))
  12. model.add(layers.Flatten())
  13. model.add(layers.Dropout(0.5))
  14. model.add(layers.Dense(512, activation='relu'))
  15. model.add(layers.Dense(1, activation='sigmoid'))
  17. model.compile(loss='binary_crossentropy',
  18.               optimizer=optimizers.RMSprop(lr=1e-4),
  19.               metrics=['acc'])

我们来训练这个使用了数据增强和 dropout 的网络 :

  1. train_datagen = ImageDataGenerator(
  2.     rescale=1./255,
  3.     rotation_range=40,
  4.     width_shift_range=0.2,
  5.     height_shift_range=0.2,
  6.     shear_range=0.2,
  7.     zoom_range=0.2,
  8.     horizontal_flip=True,)
  10. # Note that the validation data should not be augmented!
  11. test_datagen = ImageDataGenerator(rescale=1./255)
  13. train_generator = train_datagen.flow_from_directory(
  14.         # This is the target directory
  15.         train_dir,
  16.         # All images will be resized to 150x150
  17.         target_size=(150, 150),
  18.         batch_size=32,
  19.         # Since we use binary_crossentropy loss, we need binary labels
  20.         class_mode='binary')
  22. validation_generator = test_datagen.flow_from_directory(
  23.         validation_dir,
  24.         target_size=(150, 150),
  25.         batch_size=32,
  26.         class_mode='binary')
  28. history = model.fit_generator(
  29.       train_generator,
  30.       steps_per_epoch=100,
  31.       epochs=100,
  32.       validation_data=validation_generator,
  33.       validation_steps=50)

我们再次绘制结果（见图 5-12 和图 5-13）。使用了数据增强和 dropout 之后，模型不再过拟合：训练曲线紧紧跟随着验证曲线。现在的精度为 82%，比未正则化的模型提高了 15%（相对比例）。
image.pngimage.png
通过进一步使用正则化方法以及调节网络参数（比如每个卷积层的过滤器个数或网络中的层数），你可以得到更高的精度，可以达到86%或87%。但只靠从头开始训练自己的卷积神经网络，再想提高精度就十分困难，因为可用的数据太少。想要在这个问题上进一步提高精度，下一步需要使用预训练的模型，这是接下来两节的重点。

Section 2 使用预训练的卷积神经网络

预训练网络（ pretrained network）是一个保存好的网络，之前已在大型数据集（通常是大规模图像分类任务）上训练好。如果这个原始数据集足够大且足够通用，那么预训练网络学到的特征的空间层次结构可以有效地作为视觉世界的通用模型，因此这些特征可用于各种不同的计算机视觉问题，即使这些新问题涉及的类别和原始任务完全不同。
举个例子，你在 ImageNet 上训练了一个网络（其类别主要是动物和日常用品），然后将这个训练好的网络应用于某个不相干的任务，比如在图像中识别家具。

本例中，假设有一个在 ImageNet 数据集（ 140 万张标记图像， 1000 个不同的类别）上训练好的大型卷积神经网络 VGG。 ImageNet 中包含许多动物类别，其中包括不同种类的猫和狗，因此可以认为它在猫狗分类问题上也能有良好的表现。

使用预训练网络有两种方法： 特征提取（ feature extraction）和微调模型（ fine-tuning）。两种方法我们都会介绍。首先来看特征提取。

（一）特征提取（Feature extraction）

特征提取**是使用之前网络学到的表示来从新样本中提取出有趣的特征。然后将这些特征输入一个新的分类器，从头开始训练。 **

如前所述，用于图像分类的卷积神经网络包含两部分：首先是一系列池化层和卷积层，最后是一个密集连接分类器。第一部分叫作模型的卷积基**（ convolutional base）**。对于卷积神经网络而言，特征提取就是取出之前训练好的网络的卷积基，在上面运行新数据，然后在输出上面训练一个新的分类器。
image.png

为什么不应该复用密集连接分类器？ 原因在于卷积基学到的表示可能更加通用，因此更适合重复使用。卷积神经网络的特征图表示通用概念在图像中是否存在，无论面对什么样的计算机视觉问题，这种特征图都可能很有用。但是，分类器学到的表示必然是针对于模型训练的类别，其中仅包含某个类别出现在整张图像中的概率信息。此外，密集连接层的表示不再包含物体在输入图像中的位置信息。密集连接层舍弃了空间的概念，而物体位置信息仍然由卷积特征图所描述。如果物体位置对于问题很重要，那么密集连接层的特征在很大程度上是无用的。

某个卷积层提取的表示的通用性（以及可复用性）取决于该层在模型中的深度。 模型中更靠近底部的层提取的是局部的、高度通用的特征图（比如视觉边缘、颜色和纹理），而更靠近顶部的层提取的是更加抽象的概念（比如“猫耳朵”或“狗眼睛”）。 因此，如果你的新数据集与原始模型训练的数据集有很大差异，那么最好只使用模型的前几层来做特征提取，而不是使用整个卷积基。

VGG16 等模型内置于 Keras 中。你可以从 keras.applications 模块中导入。

  1. from keras.applications import VGG16
  3. conv_base = VGG16(weights='imagenet',
  4.                   include_top=False,
  5.                   input_shape=(150, 150, 3))
  • 这里向构造函数中传入了三个参数。
    • weights 指定模型初始化的权重检查点。
    • include_top 指定模型最后是否包含密集连接分类器。默认情况下，这个密集连接分类器对应于 ImageNet 的 1000 个类别。因为我们打算使用自己的密集连接分类器（只有两个类别： cat 和 dog），所以不需要包含它。
    • input_shape 是输入到网络中的图像张量的形状。这个参数完全是可选的，如果不传入这个参数，那么网络能够处理任意形状的输入。

可以查看 VGG16 网络的模型：

  1. >>> conv_base.summary()
  2. _________________________________________________________________
  3. Layer (type)                 Output Shape              Param #   
  4. =================================================================
  5. input_1 (InputLayer)         (None, 150, 150, 3)       0         
  6. _________________________________________________________________
  7. block1_conv1 (Conv2D)        (None, 150, 150, 64)      1792      
  8. _________________________________________________________________
  9. block1_conv2 (Conv2D)        (None, 150, 150, 64)      36928     
  10. _________________________________________________________________
  11. block1_pool (MaxPooling2D)   (None, 75, 75, 64)        0         
  12. _________________________________________________________________
  13. block2_conv1 (Conv2D)        (None, 75, 75, 128)       73856     
  14. _________________________________________________________________
  15. block2_conv2 (Conv2D)        (None, 75, 75, 128)       147584    
  16. _________________________________________________________________
  17. block2_pool (MaxPooling2D)   (None, 37, 37, 128)       0         
  18. _________________________________________________________________
  19. block3_conv1 (Conv2D)        (None, 37, 37, 256)       295168    
  20. _________________________________________________________________
  21. block3_conv2 (Conv2D)        (None, 37, 37, 256)       590080    
  22. _________________________________________________________________
  23. block3_conv3 (Conv2D)        (None, 37, 37, 256)       590080    
  24. _________________________________________________________________
  25. block3_pool (MaxPooling2D)   (None, 18, 18, 256)       0         
  26. _________________________________________________________________
  27. block4_conv1 (Conv2D)        (None, 18, 18, 512)       1180160   
  28. _________________________________________________________________
  29. block4_conv2 (Conv2D)        (None, 18, 18, 512)       2359808   
  30. _________________________________________________________________
  31. block4_conv3 (Conv2D)        (None, 18, 18, 512)       2359808   
  32. _________________________________________________________________
  33. block4_pool (MaxPooling2D)   (None, 9, 9, 512)         0         
  34. _________________________________________________________________
  35. block5_conv1 (Conv2D)        (None, 9, 9, 512)         2359808   
  36. _________________________________________________________________
  37. block5_conv2 (Conv2D)        (None, 9, 9, 512)         2359808   
  38. _________________________________________________________________
  39. block5_conv3 (Conv2D)        (None, 9, 9, 512)         2359808   
  40. _________________________________________________________________
  41. block5_pool (MaxPooling2D)   (None, 4, 4, 512)         0         
  42. =================================================================
  43. Total params: 14,714,688
  44. Trainable params: 14,714,688
  45. Non-trainable params: 0

最后的特征图形状为 (4, 4, 512)。我们将在这个特征上添加一个密集连接分类器。

接下来，下一步有两种方法可供选择：

  • 在你的数据集上运行卷积基，将输出保存成硬盘中的 Numpy 数组，然后用这个数据作为输入，输入到独立的密集连接分类器中。这种方法速度快，计算代价低，因为对于每个输入图像只需运行一次卷积基，而卷积基是目前流程中计算代价最高的。但出于同样的原因，这种方法不允许你使用数据增强。
  • 在顶部添加 Dense 层来扩展已有模型（即 conv_base），并在输入数据上端到端地运行整个模型。 这样你可以使用数据增强，因为每个输入图像进入模型时都会经过卷积基。但出于同样的原因，这种方法的计算代价比第一种要高很多。

method 1、不使用数据增强的快速特征提取

首先，运行ImageDataGenerator实例，将图像及其标签提取为 Numpy 数组。我们需要调用conv_base模型的 predict 方法来从这些图像中提取特征。

  1. import os
  2. import numpy as np
  3. from keras.preprocessing.image import ImageDataGenerator
  5. base_dir = '/Users/fchollet/Downloads/cats_and_dogs_small'
  7. train_dir = os.path.join(base_dir, 'train')
  8. validation_dir = os.path.join(base_dir, 'validation')
  9. test_dir = os.path.join(base_dir, 'test')
  11. datagen = ImageDataGenerator(rescale=1./255)
  12. batch_size = 20
  14. def extract_features(directory, sample_count):
  15.     features = np.zeros(shape=(sample_count, 4, 4, 512))
  16.     labels = np.zeros(shape=(sample_count))
  17.     generator = datagen.flow_from_directory(
  18.         directory,
  19.         target_size=(150, 150),
  20.         batch_size=batch_size,
  21.         class_mode='binary')
  22.     i = 0
  23.     for inputs_batch, labels_batch in generator:
  24.         features_batch = conv_base.predict(inputs_batch)
  25.         features[i * batch_size : (i + 1) * batch_size] = features_batch
  26.         labels[i * batch_size : (i + 1) * batch_size] = labels_batch
  27.         i += 1
  28.         if i * batch_size >= sample_count:
  29.             # Note that since generators yield data indefinitely in a loop,
  30.             # we must `break` after every image has been seen once.
  31.             break
  32.     return features, labels
  34. train_features, train_labels = extract_features(train_dir, 2000)
  35. validation_features, validation_labels = extract_features(validation_dir, 1000)
  36. test_features, test_labels = extract_features(test_dir, 1000)

目前，提取的特征形状为 (samples, 4, 4, 512)。我们要将其输入到密集连接分类器中，所以首先必须将其形状展平为 (samples, 8192)。

  1. train_features = np.reshape(train_features, (2000, 4 * 4 * 512))
  2. validation_features = np.reshape(validation_features, (1000, 4 * 4 * 512))
  3. test_features = np.reshape(test_features, (1000, 4 * 4 * 512))

现在你可以定义你的密集连接分类器（注意要使用 dropout 正则化），并在刚刚保存的数据和标签上训练这个分类器。

  1. from keras import models
  2. from keras import layers
  3. from keras import optimizers
  5. model = models.Sequential()
  6. model.add(layers.Dense(256, activation='relu', input_dim=4 * 4 * 512))
  7. model.add(layers.Dropout(0.5))
  8. model.add(layers.Dense(1, activation='sigmoid'))
  10. model.compile(optimizer=optimizers.RMSprop(lr=2e-5),
  11.               loss='binary_crossentropy',
  12.               metrics=['acc'])
  14. history = model.fit(train_features, train_labels,
  15.                     epochs=30,
  16.                     batch_size=20,
  17.                     validation_data=(validation_features, validation_labels))

训练速度非常快，因为你只需处理两个 Dense 层。即使在 CPU 上运行，每轮的时间也不到一秒钟。

我们来看一下训练期间的损失曲线和精度曲线：

  1. import matplotlib.pyplot as plt
  3. acc = history.history['acc']
  4. val_acc = history.history['val_acc']
  5. loss = history.history['loss']
  6. val_loss = history.history['val_loss']
  8. epochs = range(len(acc))
  10. plt.plot(epochs, acc, 'bo', label='Training acc')
  11. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  12. plt.title('Training and validation accuracy')
  13. plt.legend()
  15. plt.figure()
  17. plt.plot(epochs, loss, 'bo', label='Training loss')
  18. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  19. plt.title('Training and validation loss')
  20. plt.legend()
  22. plt.show()

image.pngimage.png

我们的验证精度达到了约 90%，比上一节从头开始训练的小型模型效果要好得多。但从图中也可以看出，虽然 dropout 比率相当大，但模型几乎从一开始就过拟合。这是因为本方法没有使用数据增强，而数据增强对防止小型图像数据集的过拟合非常重要。

method 2、使用数据增强的特征提取

下面我们来看一下特征提取的第二种方法，它的速度更慢，计算代价更高，但在训练期间可以使用数据增强。这种方法就是：扩展 conv_base 模型，然后在输入数据上端到端地运行模型。

注意：本方法计算代价很高，只在有 GPU 的情况下才能尝试运行。它在 CPU 上是绝对难以运行的。如果你无法在 GPU 上运行代码，那么就采用第一种方法。

模型的行为和层类似，所以你可以向 Sequential 模型中添加一个模型（比如 conv_base），就像添加一个层一样。

  1. from keras import models
  2. from keras import layers
  4. model = models.Sequential()
  5. model.add(conv_base)
  6. model.add(layers.Flatten())
  7. model.add(layers.Dense(256, activation='relu'))
  8. model.add(layers.Dense(1, activation='sigmoid'))
  1. >>> model.summary()
  4. _________________________________________________________________
  5. Layer (type)                 Output Shape              Param #   
  6. =================================================================
  7. vgg16 (Model)                (None, 4, 4, 512)         14714688  
  8. _________________________________________________________________
  9. flatten_1 (Flatten)          (None, 8192)              0         
  10. _________________________________________________________________
  11. dense_3 (Dense)              (None, 256)               2097408   
  12. _________________________________________________________________
  13. dense_4 (Dense)              (None, 1)                 257       
  14. =================================================================
  15. Total params: 16,812,353
  16. Trainable params: 16,812,353
  17. Non-trainable params: 0
  18. _______________________________________________________________

在编译和训练模型之前，一定要“冻结”卷积基。 冻结（ freeze）一个或多个层是指在训练过程中保持其权重不变。如果不这么做，那么卷积基之前学到的表示将会在训练过程中被修改。因为其上添加的 Dense 层是随机初始化的，所以非常大的权重更新将会在网络中传播，对之前学到的表示造成很大破坏。

  1. conv_base.trainable = False  # 冻结卷积基

如此设置之后，只有添加的两个 Dense 层的权重才会被训练。 （注意，为了让这些修改生效，你必须先编译模型。 ）

  1. from keras.preprocessing.image import ImageDataGenerator
  3. train_datagen = ImageDataGenerator(
  4.       rescale=1./255,
  5.       rotation_range=40,
  6.       width_shift_range=0.2,
  7.       height_shift_range=0.2,
  8.       shear_range=0.2,
  9.       zoom_range=0.2,
  10.       horizontal_flip=True,
  11.       fill_mode='nearest')
  13. # 注意，不能增强验证数据
  14. test_datagen = ImageDataGenerator(rescale=1./255)
  16. train_generator = train_datagen.flow_from_directory(
  17.         # This is the target directory
  18.         train_dir,
  19.         # All images will be resized to 150x150
  20.         target_size=(150, 150),
  21.         batch_size=20,
  22.         # Since we use binary_crossentropy loss, we need binary labels
  23.         class_mode='binary')
  25. validation_generator = test_datagen.flow_from_directory(
  26.         validation_dir,
  27.         target_size=(150, 150),
  28.         batch_size=20,
  29.         class_mode='binary')
  31. model.compile(loss='binary_crossentropy',
  32.               optimizer=optimizers.RMSprop(lr=2e-5),
  33.               metrics=['acc'])
  35. history = model.fit_generator(
  36.       train_generator,
  37.       steps_per_epoch=100,
  38.       epochs=30,
  39.       validation_data=validation_generator,
  40.       validation_steps=50,
  41.       verbose=2)
  43. model.save('cats_and_dogs_small_3.h5')
  • 注意，不能增强验证数据。

我们来再次绘制结果，验证精度约为 96%：
image.pngimage.png

（二）微调模型（Fine-tuning）

另一种广泛使用的模型复用方法是模型微调（ fine-tuning），与特征提取互为补充。对于用于特征提取的冻结的模型基，微调是指将其顶部的几层“解冻”，并将这解冻的几层和新增加的部分（本例中是全连接分类器）联合训练。之所以叫作微调，是因为它只是略微调整了所复用模型中更加抽象的表示，以便让这些表示与手头的问题更加相关。

image.png
前面说过，冻结 VGG16 的卷积基是为了能够在上面训练一个随机初始化的分类器。同理，只有上面的分类器已经训练好了，才能微调卷积基的顶部几层。如果分类器没有训练好，那么训练期间通过网络传播的误差信号会特别大，微调的几层之前学到的表示都会被破坏。因此，微调网络的步骤如下 ：

  1. 在已经训练好的基网络（ base network）上添加自定义网络。
  2. 冻结基网络。
  3. 训练所添加的部分。
  4. 解冻基网络的一些层。
  5. 联合训练解冻的这些层和添加的部分。

你在做特征提取时已经完成了前三个步骤。我们继续进行第四步：先解冻 conv_base，然后冻结其中的部分层。

  1. >>> conv_base.summary()
  3. _________________________________________________________________
  4. Layer (type)                 Output Shape              Param #   
  5. =================================================================
  6. input_1 (InputLayer)         (None, 150, 150, 3)       0         
  7. _________________________________________________________________
  8. block1_conv1 (Conv2D)        (None, 150, 150, 64)      1792      
  9. _________________________________________________________________
  10. block1_conv2 (Conv2D)        (None, 150, 150, 64)      36928     
  11. _________________________________________________________________
  12. block1_pool (MaxPooling2D)   (None, 75, 75, 64)        0         
  13. _________________________________________________________________
  14. block2_conv1 (Conv2D)        (None, 75, 75, 128)       73856     
  15. _________________________________________________________________
  16. block2_conv2 (Conv2D)        (None, 75, 75, 128)       147584    
  17. _________________________________________________________________
  18. block2_pool (MaxPooling2D)   (None, 37, 37, 128)       0         
  19. _________________________________________________________________
  20. block3_conv1 (Conv2D)        (None, 37, 37, 256)       295168    
  21. _________________________________________________________________
  22. block3_conv2 (Conv2D)        (None, 37, 37, 256)       590080    
  23. _________________________________________________________________
  24. block3_conv3 (Conv2D)        (None, 37, 37, 256)       590080    
  25. _________________________________________________________________
  26. block3_pool (MaxPooling2D)   (None, 18, 18, 256)       0         
  27. _________________________________________________________________
  28. block4_conv1 (Conv2D)        (None, 18, 18, 512)       1180160   
  29. _________________________________________________________________
  30. block4_conv2 (Conv2D)        (None, 18, 18, 512)       2359808   
  31. _________________________________________________________________
  32. block4_conv3 (Conv2D)        (None, 18, 18, 512)       2359808   
  33. _________________________________________________________________
  34. block4_pool (MaxPooling2D)   (None, 9, 9, 512)         0         
  35. _________________________________________________________________
  36. block5_conv1 (Conv2D)        (None, 9, 9, 512)         2359808   
  37. _________________________________________________________________
  38. block5_conv2 (Conv2D)        (None, 9, 9, 512)         2359808   
  39. _________________________________________________________________
  40. block5_conv3 (Conv2D)        (None, 9, 9, 512)         2359808   
  41. _________________________________________________________________
  42. block5_pool (MaxPooling2D)   (None, 4, 4, 512)         0         
  43. =================================================================
  44. Total params: 14,714,688
  45. Trainable params: 0
  46. Non-trainable params: 14,714,688

我们将微调最后三个卷积层，也就是说，直到 block4_pool 的所有层都应该被冻结，而 block5_conv1、 block5_conv2 和 block5_conv3 三层应该是可训练的。

为什么不微调更多层？为什么不微调整个卷积基？

  • 卷积基中更靠底部的层编码的是更加通用的可复用特征，而更靠顶部的层编码的是更专业化的特征。
  • 训练的参数越多，过拟合的风险越大。

因此，在这种情况下，一个好策略是仅微调卷积基最后的两三层。

  1. conv_base.trainable = True
  3. set_trainable = False
  4. for layer in conv_base.layers:
  5.     if layer.name == 'block5_conv1':
  6.         set_trainable = True
  7.     if set_trainable:
  8.         layer.trainable = True
  9.     else:
  10.         layer.trainable = False

现在你可以开始微调网络。我们将使用学习率非常小的 RMSProp 优化器来实现。之所以让学习率很小，是因为对于微调的三层表示，我们希望其变化范围不要太大。太大的权重更新可能会破坏这些表示。

  1. model.compile(loss='binary_crossentropy',
  2.               optimizer=optimizers.RMSprop(lr=1e-5),
  3.               metrics=['acc'])
  5. history = model.fit_generator(
  6.       train_generator,
  7.       steps_per_epoch=100,
  8.       epochs=100,
  9.       validation_data=validation_generator,
  10.       validation_steps=50)
  12. model.save('cats_and_dogs_small_4.h5')

绘制结果图：
image.pngimage.png
这些曲线看起来包含噪声。为了让图像更具可读性，你可以将每个损失和精度都替换为指数移动平均值，从而让曲线变得平滑。下面用一个简单的实用函数来实现：

  1. acc = history.history['acc']
  2. val_acc = history.history['val_acc']
  3. loss = history.history['loss']
  4. val_loss = history.history['val_loss']
  6. epochs = range(len(acc))
  8. plt.plot(epochs, acc, 'bo', label='Training acc')
  9. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  10. plt.title('Training and validation accuracy')
  11. plt.legend()
  13. plt.figure()
  15. plt.plot(epochs, loss, 'bo', label='Training loss')
  16. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  17. plt.title('Training and validation loss')
  18. plt.legend()
  20. plt.show()

image.pngimage.png
验证精度曲线变得更清楚。可以看到，精度值提高了 1%，从约 96% 提高到 97% 以上。

注意，从损失曲线上看不出与之前相比有任何真正的提高（实际上还在变差）。你可能感到奇怪，如果损失没有降低，那么精度怎么能保持稳定或提高呢？答案很简单：图中展示的是逐点（ pointwise）损失值的平均值，但影响精度的是损失值的分布，而不是平均值，因为精度是模型预测的类别概率的二进制阈值。即使从平均损失中无法看出，但模型也仍然可能在改进。

最后在测试集上评估模型：

  1. test_generator = test_datagen.flow_from_directory(
  2.         test_dir,
  3.         target_size=(150, 150),
  4.         batch_size=20,
  5.         class_mode='binary')
  7. test_loss, test_acc = model.evaluate_generator(test_generator, steps=50)
  8. print('test acc:', test_acc)

我们得到了 97% 的测试精度。在关于这个数据集的原始 Kaggle 竞赛中，这个结果是最佳结果之一。

小结

  • 卷积神经网络是用于计算机视觉任务的最佳机器学习模型。即使在非常小的数据集上也可以从头开始训练一个卷积神经网络，而且得到的结果还不错。
  • 在小型数据集上的主要问题是过拟合。在处理图像数据时，数据增强是一种降低过拟合的强大方法。
  • 利用特征提取，可以很容易将现有的卷积神经网络复用于新的数据集。
  • 作为特征提取的补充，你还可以使用微调，将现有模型之前学到的一些数据表示应用于
    新问题。这种方法可以进一步提高模型性能。

现在你已经拥有一套可靠的工具来处理图像分类问题，特别是对于小型数据集。