卷积神经网络图像分类之猫狗分类实验

一、前期工作

1. 安装anaconda
2. 新建一个工作空间，在里面依次安装jupyter notebook，TensorFlow 1.14.0，Keras 2.2.5，pillow，matplotlib
   建议在命令行中安装，更加快捷。

#创建一个名为python的工作空间，Python版本为3.7
conda  create -n python  python=3.7
#切换工作空间到python
activate python
#如果忘记了名称可以用命令查看
conda env list
#安装各种包
pip install TensorFlow=1.14.0 

不会的可以参考这篇博文

二、分类实现

1、分类训练图片

可以从Kaggle官网获得数据集，需要创建一个Kaggle帐户——别担心，这个过程是fast的：

用代码，根据train中图片名称进行简单分类：

import os, shutil
# 原始数据集解压缩所在目录的路径
original_dataset_dir = 'D:/python_project/kaggle_Dog&Cat/train'

# 创建一个存储较小数据集的目录
base_dir = 'D:/python_project/kaggle_Dog&Cat/find_cats_and_dogs'
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个cat图像以训练模型
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个猫图像复制到验证
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个猫图像到测试
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个狗图片去训练模型
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个狗图片去验证
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个狗图片去测试
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)))
print('total training dog images:', len(os.listdir(train_dogs_dir)))
print('total validation cat images:', len(os.listdir(validation_cats_dir)))
print('total validation dog images:', len(os.listdir(validation_dogs_dir)))
print('total test cat images:', len(os.listdir(test_cats_dir)))
print('total test dog images:', len(os.listdir(test_dogs_dir)))

可见猫狗训练图片各1000张，验证图片各500张，测试图片各500张。在每个分割中，每个类的样本数相同：这是一个平衡的二进制分类问题，意味着分类精度将是衡量成功的适当措施。

2、卷积神经网络

1. 网络模型搭建

model.summary()输出模型各层的参数状况，可以看到要素图的尺寸是如何随着每个连续层而变化的

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'))
model.summary()

2. 图像生成器读取文件中数据

目前数据以JPEG文件的形式存储在驱动器上，因此将其导入网络的步骤大致如下：
阅读图片文件 -> 将JPEG内容解码为RBG像素网格 -> 把它们转换成浮点张量 -> 将像素值（介于0和255之间）重新缩放到[0，1]间隔。
幸好Keras拥有自动处理这些步骤的实用程序：

from keras import optimizers

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

from keras import optimizers

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

3. 训练模型

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

可以看到其中一个生成器的输出：它生成成批的150x150 RGB图像（shape（20，150，150，3））和二进制标签（shape（20，150，3））。20是每批样品的数量（批量大小）

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

4. 保存模型，查看结果

model.save('cats_and_dogs_small_1.h5')

训练结果如下图所示，很明显模型上来就过拟合了，主要原因是数据不够，或者说相对于数据量，模型过复杂（训练损失在第30个epoch就降为0了）。

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(len(acc))

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()

3、 优化模型

为了解决过拟合问题，这里采用增加数据（图像增强、人工合成或者多搜集真实数据）去优化。

过拟合：指为了得到一致假设而使假设变得过度严格，通常表示神经网络模型在训练集上的表现很好，但是泛化能力比较差，在测试集上表现不好。
数据增强:防止过拟合，增多相应的数据来增加神经网络的深度和广度

1. 图像增强
   Keras中，可以利用图像生成器很方便地定义一些常见的图像变换。将变换后的图像送入训练之前，可以按变换方法逐个看看变换的效果：

datagen = ImageDataGenerator(
      rotation_range=40,
      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[3]

# 读取图像并调整其大小
img = image.load_img(img_path, target_size=(150, 150))

# 将其转换为具有形状的Numpy数组 (150, 150, 3)
x = image.img_to_array(img)

# 将其重塑为 (1, 150, 150, 3)
x = x.reshape((1,) + x.shape)

# 其中.flow（）命令生成一批随机转换的图像。
# 它将无限期地循环，所以我们需要在某个时刻“打破”循环！
i = 0
for batch in datagen.flow(x, batch_size=1):
    plt.figure(i)
    imgplot = plt.imshow(image.array_to_img(batch[0]))
    i += 1
    if i % 4 == 0:
        break

plt.show()

2. 进一步防止过度拟合，我们还将在我们的模型中添加一个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'])

3. 处理图像数据，训练模型

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(
        # 这是目标目录
        train_dir,
        # 所有图像的大小都将调整为 150x150
        target_size=(150, 150),
        batch_size=32,
        # 因为我们使用二进制熵损失，所以我们需要二进制标签
        class_mode='binary')

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

history = model.fit_generator(
      train_generator,
      steps_per_epoch=100,
      epochs=100,
      validation_data=validation_generator,
      validation_steps=50)

过程有点久，需要耐心等待。

4. 保存模型，查看可视化结果

model.save('cats_and_dogs_small_2.h5')

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

epochs = range(len(acc))

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()

可以看到由于数据的增加和丢失，过拟合情况消失，训练曲线相当接近于验证曲线。目前可以达到82%的精度，比非正则化模型相对提高了15%。

三、小结

网上资源千千万，需要慧眼识别。
参考链接