深度学习 Day 18——利用卷神经网络实现猫狗识别 Ⅱ
文章目录
- 深度学习 Day 18——利用卷神经网络实现猫狗识别 Ⅱ
- 一、前言
- 二、我的环境
- 三、前期工作
- 1、导入依赖项并设置GPU
- 2、导入数据
- 四、数据预处理
- 1、加载数据
- 2、检查数据
- 3、配置数据集并进行归一化处理
- 4、可视化数据
- 五、构建VGG-16网络
- 1、VGG优缺点分析
- 2、VGG结构说明
- 3、构建网络
- 六、编译模型
- 七、训练模型
- 八、模型评估
- 九、模型预测
- 十、数据增强
- 1、什么是数据增强？
- 2、数据增强的好处
- 十一、最后我想说
一、前言
- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍦 参考文章：365天深度学习训练营-第9周：猫狗识别-2（训练营内部成员可读）
- 🍖 原作者：K同学啊|接辅导、项目定制
本期深度学习博客承接上一篇，修改了上一期博客中出现的BUG，本文其他内容跟上一篇的差别不大，但本期会介绍有关数据增强方面的知识。
二、我的环境
- 电脑系统：Windows 11
- 语言环境：Python 3.8.5
- 编译器：DataSpell 2022.2
- 深度学习环境：TensorFlow 2.3.4
- 显卡及显存：RTX 3070 8G
三、前期工作
1、导入依赖项并设置GPU
导入依赖项：
import os, pathlib
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
和之前一样，如果你GPU很好就只使用GPU进行训练，如果GPU不行就推荐使用CPU训练加GPU加速。
只使用GPU：
if gpus:
gpu0 = gpus[0] #如果有多个GPU，仅使用第0个GPU
tf.config.experimental.set_memory_growth(gpu0, True) #设置GPU显存用量按需使用
tf.config.set_visible_devices([gpu0],"GPU")
使用CPU+GPU：
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
2、导入数据
# 支持中文
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
#隐藏警告
import warnings
warnings.filterwarnings('ignore')
data_dir = "E:\深度学习\data\Day17"
data_dir = pathlib.Path(data_dir)
image_count = len(list(data_dir.glob('*/*')))
print("图片总数为：",image_count)
图片总数为： 3400
四、数据预处理
1、加载数据
我们使用image_dataset_from_directory方法将我们本地的数据加载到tf.data.Dataset
中，并设置训练图片模型参数：
batch_size = 8
img_height = 224
img_width = 224
加载数据：
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=12,
image_size=(img_height, img_width),
batch_size=batch_size)
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=12,
image_size=(img_height, img_width),
batch_size=batch_size)
Found 3400 files belonging to 2 classes.
Using 2720 files for training.
Found 3400 files belonging to 2 classes.
Using 680 files for validation.
然后我们再利用class_name输出我们本地数据集的标签，标签也就是对应数据所在的文件目录名：
class_names = train_ds.class_names
print(class_names)
['cat', 'dog']
2、检查数据
在可视化数据前，我们来检查一下我们的数据信息是否是正确的：
for image_batch, labels_batch in train_ds:
print(image_batch.shape)
print(labels_batch.shape)
break
(8, 224, 224, 3)
(8,)
这是一批形状224x224x3的8张图片。
3、配置数据集并进行归一化处理
AUTOTUNE = tf.data.experimental.AUTOTUNE
def preprocess_image(image,label):
return (image/255.0,label)
# 归一化处理
train_ds = train_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)
val_ds = val_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)
train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
4、可视化数据
plt.figure(figsize=(15, 10)) # 图形的宽为15高为10
for images, labels in train_ds.take(1):
for i in range(8):
ax = plt.subplot(5, 8, i + 1)
plt.imshow(images[i])
plt.title(class_names[labels[i]])
plt.axis("off")
五、构建VGG-16网络
1、VGG优缺点分析
-
VGG优点
VGG的结构非常简洁，整个网络都使用了同样大小的卷积核尺寸（3x3）和最大池化尺寸（2x2）
-
VGG缺点
- 训练时间过长，调参难度大
- 需要的存储容量大，不利于部署。例如存储VGG-16权重值文件的大小为500多MB，不利于安装到嵌入式系统中
2、VGG结构说明
-
13个卷积层（Convolutional Layer），分别用
blockX_convX表示 -
3个全连接层（Fully connected Layer），分别用
fcX与predictions表示 -
5个池化层（Pool layer），分别用
blockX_pool表示
因为VGG-16包含了16个隐藏层**（13个卷积层和3个全连接层），故称为**`VGG-16
3、构建网络
from tensorflow.keras import layers, models, Input
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout
def VGG16(nb_classes, input_shape):
input_tensor = Input(shape=input_shape)
# 1st block
x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv1')(input_tensor)
x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv2')(x)
x = MaxPooling2D((2,2), strides=(2,2), name = 'block1_pool')(x)
# 2nd block
x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv1')(x)
x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv2')(x)
x = MaxPooling2D((2,2), strides=(2,2), name = 'block2_pool')(x)
# 3rd block
x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv1')(x)
x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv2')(x)
x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv3')(x)
x = MaxPooling2D((2,2), strides=(2,2), name = 'block3_pool')(x)
# 4th block
x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv1')(x)
x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv2')(x)
x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv3')(x)
x = MaxPooling2D((2,2), strides=(2,2), name = 'block4_pool')(x)
# 5th block
x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv1')(x)
x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv2')(x)
x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv3')(x)
x = MaxPooling2D((2,2), strides=(2,2), name = 'block5_pool')(x)
# full connection
x = Flatten()(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
output_tensor = Dense(nb_classes, activation='softmax', name='predictions')(x)
model = Model(input_tensor, output_tensor)
return model
model=VGG16(1000, (img_width, img_height, 3))
model.summary()
打印的结果是：
Model: "model"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) [(None, 224, 224, 3)] 0
block1_conv1 (Conv2D) (None, 224, 224, 64) 1792
block1_conv2 (Conv2D) (None, 224, 224, 64) 36928
block1_pool (MaxPooling2D) (None, 112, 112, 64) 0
block2_conv1 (Conv2D) (None, 112, 112, 128) 73856
block2_conv2 (Conv2D) (None, 112, 112, 128) 147584
block2_pool (MaxPooling2D) (None, 56, 56, 128) 0
block3_conv1 (Conv2D) (None, 56, 56, 256) 295168
block3_conv2 (Conv2D) (None, 56, 56, 256) 590080
block3_conv3 (Conv2D) (None, 56, 56, 256) 590080
block3_pool (MaxPooling2D) (None, 28, 28, 256) 0
block4_conv1 (Conv2D) (None, 28, 28, 512) 1180160
block4_conv2 (Conv2D) (None, 28, 28, 512) 2359808
block4_conv3 (Conv2D) (None, 28, 28, 512) 2359808
block4_pool (MaxPooling2D) (None, 14, 14, 512) 0
block5_conv1 (Conv2D) (None, 14, 14, 512) 2359808
block5_conv2 (Conv2D) (None, 14, 14, 512) 2359808
block5_conv3 (Conv2D) (None, 14, 14, 512) 2359808
block5_pool (MaxPooling2D) (None, 7, 7, 512) 0
flatten (Flatten) (None, 25088) 0
fc1 (Dense) (None, 4096) 102764544
fc2 (Dense) (None, 4096) 16781312
predictions (Dense) (None, 1000) 4097000
=================================================================
Total params: 138,357,544
Trainable params: 138,357,544
Non-trainable params: 0
_________________________________________________________________
六、编译模型
在训练我们之前我们需要对模型进行一些设置，通过model.compile函数给模型添加损失函数、优化器以及评价函数。
其中它们的作用是：
- 损失函数（loss）:用于衡量模型在训练期间的准确率。
- 优化器（optimizer）：决定模型如何根据其看到的数据和自身的损失函数进行更新。
- 评价函数（metrics）：用于监控训练和测试步骤。以下示例使用了准确率，即被正确分类的图像的比率。
model.compile(optimizer="adam",
loss ='sparse_categorical_crossentropy',
metrics =['accuracy'])
七、训练模型
使用train_on_batch训练模型
from tqdm import tqdm
import tensorflow.keras.backend as K
epochs = 10
lr = 1e-4
# 记录训练数据，方便后面的分析
history_train_loss = []
history_train_accuracy = []
history_val_loss = []
history_val_accuracy = []
for epoch in range(epochs):
train_total = len(train_ds)
val_total = len(val_ds)
"""
total：预期的迭代数目
ncols：控制进度条宽度
mininterval：进度更新最小间隔，以秒为单位（默认值：0.1）
"""
with tqdm(total=train_total, desc=f'Epoch {epoch + 1}/{epochs}',mininterval=1,ncols=100) as pbar:
lr = lr*0.92
K.set_value(model.optimizer.lr, lr)
train_loss = []
train_accuracy = []
for image,label in train_ds:
"""
训练模型，简单理解train_on_batch就是：它是比model.fit()更高级的一个用法
想详细了解 train_on_batch 的同学，
可以看看我的这篇文章：https://www.yuque.com/mingtian-fkmxf/hv4lcq/ztt4gy
"""
# 这里生成的是每一个batch的acc与loss
history = model.train_on_batch(image,label)
train_loss.append(history[0])
train_accuracy.append(history[1])
pbar.set_postfix({"train_loss": "%.4f"%history[0],
"train_acc":"%.4f"%history[1],
"lr": K.get_value(model.optimizer.lr)})
pbar.update(1)
history_train_loss.append(np.mean(train_loss))
history_train_accuracy.append(np.mean(train_accuracy))
print('开始验证！')
with tqdm(total=val_total, desc=f'Epoch {epoch + 1}/{epochs}',mininterval=0.3,ncols=100) as pbar:
val_loss = []
val_accuracy = []
for image,label in val_ds:
# 这里生成的是每一个batch的acc与loss
history = model.test_on_batch(image,label)
val_loss.append(history[0])
val_accuracy.append(history[1])
pbar.set_postfix({"val_loss": "%.4f"%history[0],
"val_acc":"%.4f"%history[1]})
pbar.update(1)
history_val_loss.append(np.mean(val_loss))
history_val_accuracy.append(np.mean(val_accuracy))
print('结束验证！')
print("验证loss为：%.4f"%np.mean(val_loss))
print("验证准确率为：%.4f"%np.mean(val_accuracy))
训练的结果如下：
Epoch 1/10: 100%|█| 340/340 [15:23<00:00, 2.72s/it, train_loss=0.6182, train_acc=0.7500, lr=9.2e-5]
开始验证！
Epoch 1/10: 100%|██████████████████| 85/85 [00:42<00:00, 2.01it/s, val_loss=0.7291, val_acc=0.3750]
结束验证！
验证loss为：0.7181
验证准确率为：0.5647
...
Epoch 10/10: 100%|█| 340/340 [17:04<00:00, 3.01s/it, train_loss=0.0001, train_acc=1.0000, lr=4.34e-
开始验证！
Epoch 10/10: 100%|█████████████████| 85/85 [00:59<00:00, 1.43it/s, val_loss=0.0000, val_acc=1.0000]
结束验证！
验证loss为：0.0567
验证准确率为：0.9838
八、模型评估
epochs_range = range(epochs)
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, history_train_accuracy, label='Training Accuracy')
plt.plot(epochs_range, history_val_accuracy, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, history_train_loss, label='Training Loss')
plt.plot(epochs_range, history_val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
上面是本次的评估图，下面是上次博客中的评估图，对比一下：
九、模型预测
# 采用加载的模型（new_model）来看预测结果
plt.figure(figsize=(18, 3)) # 图形的宽为18高为5
plt.suptitle("预测结果展示")
for images, labels in val_ds.take(1):
for i in range(8):
ax = plt.subplot(1,8, i + 1)
# 显示图片
plt.imshow(images[i].numpy())
# 需要给图片增加一个维度
img_array = tf.expand_dims(images[i], 0)
# 使用模型预测图片中的人物
predictions = model.predict(img_array)
plt.title(class_names[np.argmax(predictions)])
plt.axis("off")
1/1 [==============================] - 0s 129ms/step
1/1 [==============================] - 0s 19ms/step
1/1 [==============================] - 0s 18ms/step
1/1 [==============================] - 0s 18ms/step
1/1 [==============================] - 0s 17ms/step
1/1 [==============================] - 0s 18ms/step
1/1 [==============================] - 0s 17ms/step
1/1 [==============================] - 0s 17ms/step
预测结果如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QfchWIr9-1668156029552)(%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%20Day%2018%E2%80%94%E2%80%94%E5%88%A9%E7%94%A8%E5%8D%B7%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%E5%AE%9E%E7%8E%B0%E7%8C%AB%E7%8B%97%E8%AF%86%E5%88%AB%20%E2%85%A1.assets/image-20221111160339904.png)]
十、数据增强
1、什么是数据增强？
数据增强是通过从现有数据生成新数据点来人为增加数据量的过程。这包括对数据添加微小的更改或使用机器学习模型在原始数据的潜在空间中生成新的数据点以放大数据集。
数据增强是增加用于训练模型的数据大小的技术。对于可靠的预测，深度学习模型通常需要大量的训练数据，而这些数据并不总是可用的。因此，为了制作更好的泛化模型，对现有数据进行了扩充。
尽管数据增强可以应用于各个领域，但它通常用于计算机视觉。用于图像的一些最常见的数据增强技术是：
-
位置增强
在位置增强中，图像的像素位置会发生变化。
- 缩放：在缩放或调整大小时，图像被调整到给定大小，例如图像的宽度可以加倍。
- 裁剪：在裁剪中，选择图像的一部分，例如在给定示例中，返回中心裁剪图像。
- 翻转：在翻转中，图像水平或垂直翻转。
- 填充：在填充中，图像在所有边上都用给定的值填充。
- 回转：在填充中，图像在所有边上都用给定的值填充。
- 翻译：在平移过程中，图像沿 x 轴或 y 轴移动。
- 仿射变换：仿射变换保留点、直线和平面。它可用于缩放、平移、剪切、旋转等。
-
颜色增强
颜色增强或颜色抖动处理通过改变图像的像素值来改变图像的颜色属性。
- 亮度：一种增强的方法是改变图像的亮度。与原始图像相比，生成的图像变得更暗或更亮。
- 对比：对比度定义为图像最暗和最亮区域之间的分离程度。图像的对比度也可以改变。
- 饱和：饱和度是图像颜色之间的分离。
- 色调：色调可以描述为图像中颜色的阴影，可以将彩色图像转换为灰度以进行增强。
2、数据增强的好处
数据增强不仅有助于增加训练集的大小，还有助于避免过度拟合。通过增加数据的大小和增加数据的多样性，数据增强有助于模型更好地泛化，从而防止过度拟合。
我们需要注意的是数据增强仅适用于训练集，而不适用于测试集。
十一、最后我想说
本期博客的内容到这里就结束了，有关数据增强的详细过程以及实现过程我们将在下一期博客中学习，在这里我只是简单的介绍了一下有关数据增强的相关知识，如果你想去进一步了解数据增强的相关知识的话，你可以去看一下这几篇国外的博客：数据增强 | 数据有限时如何使用深度学习、深度学习中数据增强的基本指南
