使用深度学习分类猫狗图片

使用深度学习分类猫狗图片

• 前言
• 一、下载数据
• 二、构建网络
• 三、数据预处理
• 四、使用数据增强
• 总结

 

---

前言

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

---

提示：本案例使用keras作为训练架构

一、下载数据

 1.引入库

 本节用到的猫狗分类数据集不包含在 Keras 中。它由 Kaggle 在 2013 年末公开并作为一项 计算视觉竞赛的一部分，当时卷积神经网络还不是主流算法。你可以从 https://www.kaggle.com/ c/dogs-vs-cats/data 下载原始数据集。这些图像都是中等分辨率的彩色 JPEG 图像。

  2.将图像复制到训练、验证和测试的目录

分别为猫，狗创建训练、验证、测试文件夹

import os, shutil

#原始数据集解压目录的路径
original_dataset_dir = '/Users/fchollet/Downloads/kaggle_original_data'

#保存较小数据集的目录
base_dir = '/Users/fchollet/Downloads/cats_and_dogs_small' 
os.mkdir(base_dir)

#分别对应划分后的训练、 验证和测试的目录
train_dir = os.path.join(base_dir, 'train') 
os.mkdir(train_dir)
validation_dir = os.path.join(base_dir, 'validation') 
os.mkdir(validation_dir)
test_dir = os.path.join(base_dir, 'test') 
os.mkdir(test_dir)
# 猫、狗的训练集
train_cats_dir = os.path.join(train_dir, 'cats') 
os.mkdir(train_cats_dir)
train_dogs_dir = os.path.join(train_dir, 'dogs')
os.mkdir(train_dogs_dir)
# 猫、狗的验证集
validation_cats_dir = os.path.join(validation_dir, 'cats') 
os.mkdir(validation_cats_dir)
validation_dogs_dir = os.path.join(validation_dir, 'dogs') 
os.mkdir(validation_dogs_dir)
# 猫、狗的测试集
test_cats_dir = os.path.join(test_dir, 'cats') 
os.mkdir(test_cats_dir)
test_dogs_dir = os.path.join(test_dir, 'dogs') 
os.mkdir(test_dogs_dir)

将猫咪的图片复制到对应的文件夹中

"""
将前 1000 张猫的图像复制 到 train_cats_dir
"""
fnames = ['cat.{}.jpg'.format(i) for i in range(1000)] 
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname) 
    dst = os.path.join(train_cats_dir, fname) 
    shutil.copyfile(src, dst)
"""
将接下来 500 张猫的图像复 制到 validation_cats_dir
"""
fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)] 
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname) 
    dst = os.path.join(validation_cats_dir, fname) 
    shutil.copyfile(src, dst)
"""
将接下来的 500 张猫的图像 复制到 test_cats_dir
"""
fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)] 
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname) 
    dst = os.path.join(test_cats_dir, fname) 
    shutil.copyfile(src, dst)

 将狗的照片复制到对应的文件夹中

"""
将前 1000 张狗的图像复制 到 train_dogs_dir
"""
fnames = ['dog.{}.jpg'.format(i) for i in range(1000)] 
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname) 
    dst = os.path.join(train_dogs_dir, fname) 
    shutil.copyfile(src, dst)
"""
将接下来 500 张狗的图像复 制到 validation_dogs_dir
"""
fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)] 
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname) 
    dst = os.path.join(validation_dogs_dir, fname) 
    shutil.copyfile(src, dst)
"""
将接下来 500 张狗的图像复 制到 test_dogs_dir
"""
fnames = ['dog.{}.jpg'.format(i) for i in range(1500, 2000)] 
for fname in fnames:
    src = os.path.join(original_dataset_dir, fname) 
    dst = os.path.join(test_dogs_dir, fname) 
    shutil.copyfile(src, dst)

我们来检查一下，看看每个分组(训练 / 验证 / 测试)中分别包含多少张图像。

>>> print('total training cat images:', len(os.listdir(train_cats_dir))) 
total training cat images: 1000
>>> print('total training dog images:', len(os.listdir(train_dogs_dir))) 
total training dog images: 1000
>>> print('total validation cat images:', len(os.listdir(validation_cats_dir))) 
total validation cat images: 500
>>> print('total validation dog images:', len(os.listdir(validation_dogs_dir))) 
total validation dog images: 500
>>> print('total test cat images:', len(os.listdir(test_cats_dir))) 
total test cat images: 500
>>> print('total test dog images:', len(os.listdir(test_dogs_dir))) 
total test dog images: 500

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

二、建立模型

我将要构建一个小型卷积神经网络，即复用相同的总体结构，即卷积神经网络由 Conv2D 层(使用 relu 激活)和 MaxPooling2D 层交替堆叠构成。

但由于这里要处理的是更大的图像和更复杂的问题，你需要相应地增大网络，即再增加一 个 Conv2D+MaxPooling2D 的组合。这既可以增大网络容量，也可以进一步减小特征图的尺寸， 使其在连接 Flatten 层时尺寸不会太大。本例中初始输入的尺寸为 150×150(有些随意的选 择)，所以最后在 Flatten 层之前的特征图大小为 7×7。

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

1.小型卷积神经网络实例化

代码如下（示例）：

from keras import layers
from keras import models

model = models.Sequential() 
model.add(layers.Conv2D(32, (3, 3), activation='relu',
                                input_shape=(150, 150, 3)))     
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu')) 
model.add(layers.MaxPooling2D((2, 2))) 
model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
model.add(layers.MaxPooling2D((2, 2))) 
model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten()) 
model.add(layers.Dense(512, activation='relu')) 
model.add(layers.Dense(1, activation='sigmoid'))

2.我们来看一下特征图的维度如何随着每层变化。

代码如下（示例）：

>>> model.summary()
_________________________________________________________________

Layer (type) Output Shape Param # 
=================================================================
conv2d_1 (Conv2D) (None, 148, 148, 32) 896 
_________________________________________________________________
max_pooling2d_1 (MaxPooling2D) (None, 74, 74, 32) 0 
_________________________________________________________________
conv2d_2 (Conv2D) (None, 72, 72, 64) 18496 
_________________________________________________________________
max_pooling2d_2 (MaxPooling2D) (None, 36, 36, 64) 0 
_________________________________________________________________
conv2d_3 (Conv2D) (None, 34, 34, 128) 73856 
_________________________________________________________________
max_pooling2d_3 (MaxPooling2D) (None, 17, 17, 128) 0 
_________________________________________________________________
conv2d_4 (Conv2D) (None, 15, 15, 128) 147584 
_________________________________________________________________
max_pooling2d_4 (MaxPooling2D) (None, 7, 7, 128) 0 
_________________________________________________________________
flatten_1 (Flatten) (None, 6272) 0 
_________________________________________________________________ 
5 dense_1 (Dense) (None, 512) 3211776 
_________________________________________________________________
dense_2 (Dense) (None, 1) 513 
=================================================================
Total params: 3,453,121
Trainable params: 3,453,121
Non-trainable params: 0

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

3.配置模型用于训练

from keras import optimizers

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

三、数据预处理

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

1.  读取图像文件。

2.  将 JPEG 文件解码为 RGB 像素网格。

3.  将这些像素网格转换为浮点数张量。

4.  将像素值(0~255 范围内)缩放到 [0, 1] 区间(正如你所知，神经网络喜欢处理较小的输入值)。

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

使用 ImageDataGenerator 从目录中读取图像

from keras.preprocessing.image import ImageDataGenerator

"""
将所有的像素除以255，保证数值大小在[0,1]之间
"""
train_datagen = ImageDataGenerator(rescale=1./255) 
test_datagen = ImageDataGenerator(rescale=1./255)

"""
Python 生成器(Python generator)是一个类似于迭代器的对象，一个可以和 for ... in 运算符一起使用的对象。生成器是用 yield 运算符来构造的。
将图像大小调整为150*150
"""
train_generator = train_datagen.flow_from_directory(
    train_dir, 
    target_size=(150, 150), 
    batch_size=20, 
    class_mode='binary')

"""
因为使用了binary_crossentropy损失，所以需要用二进制标签
"""
validation_generator = test_datagen.flow_from_directory( 
    validation_dir,
    target_size=(150, 150), 
    batch_size=20, 
    class_mode='binary')

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

>>> for data_batch, labels_batch in train_generator:
>>> print('data batch shape:', data_batch.shape)
>>> print('labels batch shape:', labels_batch.shape) 
>>> break
data batch shape: (20, 150, 150, 3) labels batch shape: (20,)

 利用生成器，我们让模型对数据进行拟合。我们将使用 fit_generator 方法来拟合，它 在数据生成器上的效果和 fit 相同。它的第一个参数应该是一个 Python 生成器，可以不停地生 成输入和目标组成的批量，比如 train_generator。因为数据是不断生成的，所以 Keras 模型 要知道每一轮需要从生成器中抽取多少个样本。这是 steps_per_epoch 参数的作用:从生成 器中抽取 steps_per_epoch 个批量后(即运行了 steps_per_epoch 次梯度下降)，拟合过程 将进入下一个轮次。本例中，每个批量包含 20 个样本，所以读取完所有 2000 个样本需要 100 个批量。

使用 fit_generator 时，你可以传入一个 validation_data 参数，其作用和在 fit 方 法中类似。值得注意的是，这个参数可以是一个数据生成器，但也可以是 Numpy 数组组成的元 组。如果向 validation_data 传入一个生成器，那么这个生成器应该能够不停地生成验证数 据批量，因此你还需要指定 validation_steps 参数，说明需要从验证生成器中抽取多少个批 次用于评估。

利用批量生成器拟合模型

history = model.fit_generator( 
    train_generator,
    steps_per_epoch=100,
    epochs=30, 
    validation_data=validation_generator, 
    validation_steps=50)
model.save('cats_and_dogs_small_1.h5')

绘制训练过程中的损失曲线和精度曲线

import matplotlib.pyplot as plt

acc = history.history['acc']
val_acc = history.history['val_acc'] 
loss = history.history['loss'] 
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, acc, 'bo', label='Training acc') 
plt.plot(epochs, val_acc, 'b', label='Validation acc') 
plt.title('Training and validation accuracy') 
plt.legend()

plt.figure()

plt.plot(epochs, loss, 'bo', label='Training loss') 
plt.plot(epochs, val_loss, 'b', label='Validation loss') 
plt.title('Training and validation loss')
plt.legend()

plt.show()

训练精度曲线如下：

训练损失和验证损失：

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

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

四、使用数据增强

在 Keras 中，这可以通过对 ImageDataGenerator 实例读取的图像执行多次随机变换来实 现。我们先来看一个例子。

datage = ImageDataGenerator(
        rotation_range = 40,      # 是角度值(在 0~180 范围内)，表示图像随机旋转的角度范围。
        width_shift_range = 0.2,  # 是图像在水平或垂直方向上平移的范围(相对于总宽度或总高度的比例)。
        height_shift_range= 0.2,
        shear_range= 0.2,         # 是随机错切变换的角度。
        zoom_range= 0.2,          # 是图像随机缩放的范围
        horizontal_flip= True,    # 是随机将一半图像水平翻转。如果没有水平不对称的假设
        fill_mode= 'nearest'      # 是用于填充新创建像素的方法，
    )

显示几个增强训练后的训练图像，代码如下：

from keras.preprocessing import image

fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]
img_path = fnames[100]
img = image.load_img(img_path, target_size=(150, 150))
x = image.img_to_array(img) # 将其转换为形状 (150, 150, 3) 的 Numpy 数组
x = x.reshape((1,) + x.shape) # 将其形状改变为 (1, 150, 150, 3)

i =0
train_generator = datage.flow(x, batch_size=1)
for batch in train_generator:
    plt.figure(i)
    imgplot = plt.imshow(image.array_to_img(batch[0]))
    i += 1
    if i%4 == 0:
        break
plt.show()

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

model = models.Sequential() 
model.add(layers.Conv2D(32, (3, 3), activation='relu',
                            input_shape=(150, 150, 3))) 
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu')) 
model.add(layers.MaxPooling2D((2, 2))) 
model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
model.add(layers.MaxPooling2D((2, 2))) 
model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) 
model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4),
            metrics=['acc'])

更改完成神经网络模型后，再利用数据增强生成器训练卷积神经网络

    train_datagen = ImageDataGenerator( rescale=1./255,
        rotation_range=40,
        width_shift_range=0.2, 
        height_shift_range=0.2,
        shear_range=0.2, 
        zoom_range=0.2, 
        horizontal_flip=True,)

    test_datagen = ImageDataGenerator(rescale=1./255)#  不能增强验证数据集

    train_generator = train_datagen.flow_from_directory(
        dataProcess.train_dir,  # 路径
        target_size=(150, 150),  # 图像大小
        batch_size=20,  # 每批量样本大小
        class_mode='binary'  # 因为使用了binary_crossentropy损失函数，所以用二进制标签
    )

    validation_generator = test_datagen.flow_from_directory(
        dataProcess.validation_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary'
    )


    history = model.fit_generator(
        train_generator,
        steps_per_epoch=100,  # 2000/20
        epochs=100,
        validation_data=validation_generator,  # 也可以用元组作为参数
        validation_steps=50  # 说明要从验证生成器中抽取多少个批次用于评估
    )

    # 记得讲训练好的模型保存下来
    model.save('cats_and_dogs_small_1.h5')

最后，将训练、验证数据集中的acc与loss打印出来，绘制出图表，代码如下：

    acc = history.history['acc']
    val_acc = history.history['val_acc']
    loss = history.history['loss']
    val_loss = history.history['val_loss']

    print("acc", acc)
    print("val_acc", val_acc)
    print("loss", loss)
    print("val_loss", val_loss)





    epochs = range(1, len(acc) + 1)
    plt.plot(epochs, acc, 'bo', label='Training acc')
    plt.plot(epochs, val_acc, 'b', label='Validation acc')
    plt.title('Training and validation accuracy')
    plt.legend()
    plt.figure()
    plt.plot(epochs, loss, 'bo', label='Training loss')
    plt.plot(epochs, val_loss, 'b', label='Validation loss')
    plt.title('Training and validation loss')
    plt.legend()

    plt.show()

最后显示出来的loss变化图像如下：

acc变化图像如下：

可以看到，最后的验证准确率可以到达82%

 

总结

懒得写了