devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

卷积神经网络狗猫数据集的分类

作者：小蓝xlanll | 2024-05-17 04:27:47

赞

踩

猫狗分类数据集

卷积神经网络狗猫数据集的分类

环境搭建

安装Anaconda

具体安装过程，请自行百度

配置TensorFlow、Keras

  1. 创建虚拟环境

输入下面命令：

  1. conda create -n ppqppl_tfl python=3.6
  2. #tf1是自己为创建虚拟环境取的名字，后面python的版本可以根据自己需求进行选择
  1. 激活环境

使用下面命令：

  1. activate
  2. conda activate ppqppl_tfl

image

  1. 安装tensorflow和keras

使用下面命令：

  1. pip install 包名
  2. #直接这样安装可以由于网络的原因，安装失败或者安装很慢
  3. #解决方式：
  4. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
  5. #此次安装命令如下：
  6. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow==1.14.0
  7. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple keras==2.2.5
  8. # 安装 nb_conda_kernels 包
  9. conda install nb_conda_kernels
  10. # 如果上述命令报错，请更换下载源
  11. # 经检测，这里清华源下载最快，注意，这里不能使用梯子

安装完成后，我们需要在指定虚拟环境中新建一个 jupyter notebook 项目，执行如下命令即可将指定环境添加到 jupyter notebook 中：

  1. # 第一步，切换到想要添加的虚拟环境：
  2. conda activate data
  3.  
  4. # 第二步，安装ipykernel包
  5. conda install ipykernel
  6.  
  7. # 第三部，执行如下命令，并确定环境的名称(此处设置为data)
  8. python -m ipykernel install --name data

然后我们启动 jupyter notebook，创建一个指定环境下的文件即可

这样我们的环境配置就已经成功了

猫狗数据分类建模

猫狗图片数据集下载：https://pan.baidu.com/s/1f-MvZl7_J6DF7P9CGBY3SQ ——提取码：ruyn

数据集下载完毕后，解压缩，并放在一个没有中文路径下，如下图所示：

image

猫狗图像预处理

对猫狗图像进行分类，代码如下：

  1. import os, shutil 
  2. # 原始目录所在的路径
  3. original_dataset_dir = 'D:\\code-file\\conda\\kaggle_Dog&Cat\\train\\'
  4.  
  5. # 数据集分类后的目录
  6. base_dir = 'D:\\code-file\\conda\\kaggle_Dog&Cat\\train1'
  7. os.mkdir(base_dir)
  8.  
  9. # # 训练、验证、测试数据集的目录
  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)
  16.  
  17. # 猫训练图片所在目录
  18. train_cats_dir = os.path.join(train_dir, 'cats')
  19. os.mkdir(train_cats_dir)
  20.  
  21. # 狗训练图片所在目录
  22. train_dogs_dir = os.path.join(train_dir, 'dogs')
  23. os.mkdir(train_dogs_dir)
  24.  
  25. # 猫验证图片所在目录
  26. validation_cats_dir = os.path.join(validation_dir, 'cats')
  27. os.mkdir(validation_cats_dir)
  28.  
  29. # 狗验证数据集所在目录
  30. validation_dogs_dir = os.path.join(validation_dir, 'dogs')
  31. os.mkdir(validation_dogs_dir)
  32.  
  33. # 猫测试数据集所在目录
  34. test_cats_dir = os.path.join(test_dir, 'cats')
  35. os.mkdir(test_cats_dir)
  36.  
  37. # 狗测试数据集所在目录
  38. test_dogs_dir = os.path.join(test_dir, 'dogs')
  39. os.mkdir(test_dogs_dir)
  40.  
  41. # 将前1000张猫图像复制到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)
  47.  
  48. # 将下500张猫图像复制到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)
  54.     
  55. # 将下500张猫图像复制到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)
  61.     
  62. # 将前1000张狗图像复制到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)
  68.     
  69. # 将下500张狗图像复制到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)
  75.     
  76. # 将下500张狗图像复制到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)

分类后如下图所示：

image

image

查看分类后，对应目录下的图片数量：

  1. #输出数据集对应目录下图片数量
  2. print('total training cat images:', len(os.listdir(train_cats_dir)))
  3. print('total training dog images:', len(os.listdir(train_dogs_dir)))
  4. print('total validation cat images:', len(os.listdir(validation_cats_dir)))
  5. print('total validation dog images:', len(os.listdir(validation_dogs_dir)))
  6. print('total test cat images:', len(os.listdir(test_cats_dir)))
  7. print('total test dog images:', len(os.listdir(test_dogs_dir)))

image

猫狗训练图片各 1000 张，验证图片各 500 张，测试图片各 500 张

猫狗分类的实例——基准模型

构建网络模型：

  1. #网络模型构建
  2. from keras import layers
  3. from keras import models
  4. #keras的序贯模型
  5. model = models.Sequential()
  6. #卷积层，卷积核是3*3，激活函数relu
  7. model.add(layers.Conv2D(32, (3, 3), activation='relu',
  8.                         input_shape=(150, 150, 3)))
  9. #最大池化层
  10. model.add(layers.MaxPooling2D((2, 2)))
  11. #卷积层，卷积核2*2，激活函数relu
  12. model.add(layers.Conv2D(64, (3, 3), activation='relu'))
  13. #最大池化层
  14. model.add(layers.MaxPooling2D((2, 2)))
  15. #卷积层，卷积核是3*3，激活函数relu
  16. model.add(layers.Conv2D(128, (3, 3), activation='relu'))
  17. #最大池化层
  18. model.add(layers.MaxPooling2D((2, 2)))
  19. #卷积层，卷积核是3*3，激活函数relu
  20. model.add(layers.Conv2D(128, (3, 3), activation='relu'))
  21. #最大池化层
  22. model.add(layers.MaxPooling2D((2, 2)))
  23. #flatten层，用于将多维的输入一维化，用于卷积层和全连接层的过渡
  24. model.add(layers.Flatten())
  25. #全连接，激活函数relu
  26. model.add(layers.Dense(512, activation='relu'))
  27. #全连接，激活函数sigmoid
  28. model.add(layers.Dense(1, activation='sigmoid'))

运行后出现以下错误：

image

这是由于 numpy 版本与 tensorflow 版本不匹配的问题，安装 1.16.4 版本的 numpy 即可，命令如下：

pip install numpy==1.16.4 -i "https://pypi.doubanio.com/simple/"

重新再运行程序，就没有错误了，但是有警告(因为版本比较老了)，没事

查看模型各层的参数状况：

  1. #输出模型各层的参数状况
  2. model.summary()

结果如下图所示：

image

配置优化器：

loss：计算损失，这里用的是交叉熵损失

metrics：列表，包含评估模型在训练和测试时的性能的指标

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

图片格式转化

所有图片(2000张)重设尺寸大小为 150x150 大小，并使用 ImageDataGenerator 工具将本地图片 .jpg 格式转化成 RGB 像素网格，再转化成浮点张量上传到网络上

  1. from keras.preprocessing.image import ImageDataGenerator
  2.  
  3. # 所有图像将按1/255重新缩放
  4. train_datagen = ImageDataGenerator(rescale=1./255)
  5. test_datagen = ImageDataGenerator(rescale=1./255)
  6.  
  7. train_generator = train_datagen.flow_from_directory(
  8.         # 这是目标目录
  9.         train_dir,
  10.         # 所有图像将调整为150x150
  11.         target_size=(150, 150),
  12.         batch_size=20,
  13.         # 因为我们使用二元交叉熵损失，我们需要二元标签
  14.         class_mode='binary')
  15.  
  16. validation_generator = test_datagen.flow_from_directory(
  17.         validation_dir,
  18.         target_size=(150, 150),
  19.         batch_size=20,
  20.         class_mode='binary')

输出结果：

image

查看上述图像预处理过程中生成器的输出

  1. #查看上面对于图片预处理的处理结果
  2. for data_batch, labels_batch in train_generator:
  3.     print('data batch shape:', data_batch.shape)
  4.     print('labels batch shape:', labels_batch.shape)
  5.     break

如果出现错误：ImportError: Could not import PIL.Image. The use of load_img requires PIL，是因为没有安装 pillow 库导致的，使用如下命令在 ppqppl_tfl 虚拟环境中安装：

pip install pillow -i https://pypi.tuna.tsinghua.edu.cn/simple

安装完毕后，关闭 Jupyter Notebook 重新打开，重新运行一遍程序即可

输出结果如下：

image

开始训练模型(此时，我的电脑在飞速运转…)

  1. #模型训练过程
  2. history = model.fit_generator(
  3.       train_generator,
  4.       steps_per_epoch=100,
  5.       epochs=30,
  6.       validation_data=validation_generator,
  7.       validation_steps=50)

电脑性能越好，它训练得越快

image

保存模型

  1. #保存训练得到的的模型
  2. model.save('G:\\Cat_And_Dog\\kaggle\\cats_and_dogs_small_1.h5')

结果可视化

  1. #对于模型进行评估，查看预测的准确性
  2. import matplotlib.pyplot as plt
  3.  
  4. acc = history.history['acc']
  5. val_acc = history.history['val_acc']
  6. loss = history.history['loss']
  7. val_loss = history.history['val_loss']
  8.  
  9. epochs = range(len(acc))
  10.  
  11. plt.plot(epochs, acc, 'bo', label='Training acc')
  12. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  13. plt.title('Training and validation accuracy')
  14. plt.legend()
  15.  
  16. plt.figure()
  17.  
  18. plt.plot(epochs, loss, 'bo', label='Training loss')
  19. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  20. plt.title('Training and validation loss')
  21. plt.legend()
  22.  
  23. plt.show()

image

训练结果如上图所示，很明显模型上来就过拟合了，主要原因是数据不够，或者说相对于数据量，模型过复杂(训练损失在第 30 个 epoch 就降为 0 了)，训练精度随着时间线性增长，直到接近 100%，而我们的验证精度停留在 70-72%。我们的验证损失在 5 个 epoch 后达到最小，然后停止，而训练损失继续线性下降，直到接近 0

数据增强

什么是数据增强？

数据集增强主要是为了减少网络的过拟合现象，通过对训练图片进行变换可以得到泛化能力更强的网络，更好的适应应用场景。

常用的数据增强方法有：

image

重新构建模型：

上面建完的模型就保留着，我们重新建一个 .ipynb 文件，重新开始建模。

首先猫狗图像预处理，只不过这里将分类好的数据集放在 train2 文件夹中，其它的都一样

然后配置网络模型、构建优化器，然后进行数据增强，代码如下：

图像数据生成器增强数据：

  1. from keras.preprocessing.image import ImageDataGenerator
  2. datagen = ImageDataGenerator(
  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,
  9.       fill_mode='nearest')

参数解释：

image

查看数据增强后的效果：

  1. import matplotlib.pyplot as plt
  2. # This is module with image preprocessing utilities
  3. from keras.preprocessing import image
  4. fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]
  5. # We pick one image to "augment"
  6. img_path = fnames[3]
  7. # Read the image and resize it
  8. img = image.load_img(img_path, target_size=(150, 150))
  9. # Convert it to a Numpy array with shape (150, 150, 3)
  10. x = image.img_to_array(img)
  11. # Reshape it to (1, 150, 150, 3)
  12. x = x.reshape((1,) + x.shape)
  13. # The .flow() command below generates batches of randomly transformed images.
  14. # It will loop indefinitely, so we need to `break` the loop at some point!
  15. i = 0
  16. for batch in datagen.flow(x, batch_size=1):
  17.     plt.figure(i)
  18.     imgplot = plt.imshow(image.array_to_img(batch[0]))
  19.     i += 1
  20.     if i % 4 == 0:
  21.         break
  22. plt.show()

image

图片格式转化

  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,)
  9. # Note that the validation data should not be augmented!
  10. test_datagen = ImageDataGenerator(rescale=1./255)
  11. train_generator = train_datagen.flow_from_directory(
  12.         # This is the target directory
  13.         train_dir,
  14.         # All images will be resized to 150x150
  15.         target_size=(150, 150),
  16.         batch_size=32,
  17.         # Since we use binary_crossentropy loss, we need binary labels
  18.         class_mode='binary')
  19. validation_generator = test_datagen.flow_from_directory(
  20.         validation_dir,
  21.         target_size=(150, 150),
  22.         batch_size=32,
  23.         class_mode='binary')

image

开始训练并保存结果

  1. history = model.fit_generator(
  2.       train_generator,
  3.       steps_per_epoch=100,
  4.       epochs=100,
  5.       validation_data=validation_generator,
  6.       validation_steps=50)
  7. model.save('E:\\Cat_And_Dog\\kaggle\\cats_and_dogs_small_2.h5')

image

结果可视化：

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

如下图所示：

image

由于数据量的增加，对比基准模型，可以很明显的观察到曲线没有过度拟合了，训练曲线紧密地跟踪验证曲线，这也就是数据增强带来的影响，但是可以发现它的波动幅度还是比较大的

下面在此数据增强的基础上，再增加一层 dropout 层，再来训练看看

dropout 层

什么是dropout层？

Dropout层在神经网络层当中是用来干嘛的呢？它是一种可以用于减少神经网络过拟合的结构，那么它具体是怎么实现的呢？

假设下图是我们用来训练的原始神经网络：

image

一共有四个输入 xi，一个输出 y 。Dropout 则是在每一个 batch 的训练当中随机减掉一些神经元，而作为编程者，我们可以设定每一层 dropout(将神经元去除的的多少)的概率，在设定之后，就可以得到第一个 batch 进行训练的结果：

image

从上图我们可以看到一些神经元之间断开了连接，因此它们被 dropout 了！dropout顾名思义就是被拿掉的意思，正因为我们在神经网络当中拿掉了一些神经元，所以才叫做 dropout 层

具体实现：

在数据增强的基础上，再添加一个 dropout 层

  1. #退出层
  2. model.add(layers.Dropout(0.5))

如下图所示，仅在构建网络模型时添加一层即可，其余部分不变：

image

再次训练模型，查看训练结果如下：

image

相比于只使用数据增强的效果来看，额外添加一层 dropout 层，仔细对比，可以发现训练曲线更加紧密地跟踪验证曲线，波动的幅度也降低了些，训练效果更棒了

参考资料

Jupyter Notebook如何调用指定的虚拟环境

基于Tensorflow和Keras实现卷积神经网络CNN

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/581977
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号