第五章 深度学习用于计算机视觉（二）

5.2 在小型数据集上从头开始训练一个卷积神经网络

• 数据集是Kaggle中的dogs_vs_cats是一个典型的图像分类问题
• 可能需要使用GPU，GPU如果没有可以使用Google Colab中的免费GPU。

---

        Kaggle中的这个数据集中一共有25000张图片，其中猫狗各有12500张。数据集中已经分好了测试数据和训练数据。当然现在机器学习算法发展迅速，我们可以仅仅使用4000张猫狗的图片（2000张猫，2000张狗）使得训练结果就非常好。我们将2000张图像用于训练，1000张用于验证，1000张用于测试。（当然数据集越大训练结果越好，但是这里研究的是小数据集，因为后面还会介绍数据增强等内容，所以小数据集再合适不过了）

        首先要进行数据的下载工作，直接从kaggle下载就可以了https://www.kaggle.com/c/dogs-vs-cats/data。

        文件夹中已经分好了测试集和训练集。kaggle账号注册很简单，但是要下载数据集需要验证你的手机号，这一步有时候并不太容易做到。那么就去网上找找吧，应该很容易找到，CSDN也有。

        这是数据集中的内容，将文件解压到你电脑的相应地址就可以在jupyter notebook上进行学习了。但是jupyter notebook使用的是本地的CPU（如果你没有GPU的话，有就当我没说），训练速度比较慢。

要使用Google Colab首先要挂载Google Drive ，操作方法可以参考这个博文https://blog.csdn.net/qq_43028656/article/details/119849938。

        我们要使用4000张图片，下面进行数据的整理：

import os,shutil

original_dataset_dir = 'D:/ALL_code\Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data/train' #设置原始数据的路径

base_dir = 'D:/ALL_code/Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data/cats_and_dogs_small'
os.mkdir(base_dir) #由于只使用数据中的一部分 两千张cat两千张dog，所以在文件夹中创建一个较小的文件集合用以存放部分数据

train_dir = os.path.join(base_dir, 'train')
#将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)
#在train文件夹里建立cats和dogs的文件夹，存储用于训练的图片

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)
#在validation文件夹里建立两个文件夹，cats和dogs，存储用于验证的图片

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)
#在test中建立两个文件夹，用于存取测试用的图片

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)
#将前1000张猫的图片复制到train_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张猫的图像复制到validation_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)
# 将接下来500张猫的图像复制到test_cats_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)
#将前1000张狗的图片复制到train_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张狗的图像复制到validation_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)
# 将接下来500张狗的图像复制到test_dogs_dir
# 自己的硬盘大概运行45s

 完成后将会看到文件夹里面的内容是这样的，每个文件夹里都有cat和dog文件夹，里面分别存放着猫和狗的图片。到这里我们需要用到的数据就整理好了。

 接下来是模型构建和配置，数据预处理以及训练：

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

#第一个conv2d要进行参数计算是896 896=（9*3+1）*32 9是（3，3）的滤镜数据量，原市数据(150, 150, 3)通道数为3 所以要9*3 +1是截距项
#一共有32层 所以×32

#配置用于训练的模型
from keras import optimizers
model.compile(loss='binary_crossentropy', 
              optimizer=optimizers.RMSprop(lr=1e-4),
             metrics=['acc'])

数据预处理

将数据输入神经网络之前，应该将数据格式化为胫骨哦预处理的浮点数张量
步骤如下：

• 读取图像文件
• 将JPEG文件解码为RGB像素网格
• 将这些像素网格转换为浮点数张量
• 将像素值（0~255范围内）缩放到[0,1]区间

keras拥有自动完成这些步骤的工具
图像辅助模块： keras.preprocessing.image包含ImageDataGenerator类,可以快速创建python生成器

from keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

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

 运行后有如下输出，说明我们需要使用的数据已经预处理完成

Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.

#使用批量生成器拟合模型
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')#保存模型

        这个过程在我自己的CPU上跑一个epoch大概需要55s，在云端的GPU上跑一个epoch只需要13s, 但是第一个epoch比较慢（我跑了1305s）具体原因我也没有找到，但是整体来说还是GPU跑得快。

#绘制损失曲线和精度曲线
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。深度学习处理图像时的几乎都会使用到数据增强来解决过拟合。

数据增强 ( data augmentation)

• 计算机视觉领域经常使用的处理过拟合的方法
• 实现：利用多种能够生成可信图像的随机变换来增加样本
• keras中使用ImageDataGenerator实例读取的图像执行多次随机变换来实现

original_dataset_dir = 'D:/ALL_code/Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data' 

base_dir = 'D:/ALL_code/Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data/cats_and_dogs_small'
# os.mkdir(base_dir) 
train_dir = 'D:/ALL_code/Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data/cats_and_dogs_small/train'
validation_dir = 'D:/ALL_code/Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data/cats_and_dogs_small/validation'
test_dir = 'D:/ALL_code/Anaconda/Deep_Learning_Study/chapter5/kaggle_original_data/cats_and_dogs_small/test'

from keras.preprocessing.image import ImageDataGenerator
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, # 随机将一半图像水平翻转
    )# 用于填充新创建像素的方法

        使用了数据增强以后还不能完全消除过拟合，由于数据来自于少量的原市图像，所以网络看到的输入仍然是高度相关的。为了进一步降低过拟合，向模型中添加一个Dropout层，添加到密集连接分类器之前。

#定义一个包含dropout的新卷积神经网络
from keras import layers 
from keras import models
from keras import optimizers

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.Dropout(0.5))
model.add(layers.Flatten())
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(
    train_dir, 
    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)

model.save('cats_and_dogs_small_2.h5')

        这一过程在CPU上面一个epoch要持续90s左右，100个epoch跑了两个半小时，在GPU上只跑了半个小时。注意：发现一个问题，在GPU上跑的时候设置batch_size=32,会报错，说训练的范围查过了数据的范围，由于只有2000个训练资料，设置32个epoch会超出2000的范围，所以我训练的时候将32改回了原来的20。奇怪的是在本地CPU上跑的时候并没有报这个错误，查资料也没查出个所以然。。。

#绘制损失曲线和精度曲线
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()

 绘制结果如下：

 现在得到的精度达到了84%左右，比未正则的模型提高了15%（相对比例），通过进一步的正则以及调节网络参数可以使结果更好，接下来的内容会继续讲述。