365天深度学习训练营-第T9周：猫狗识别2

 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
🍖 参考原作者：K同学啊|接辅导、项目定制

🏡 我的环境：

      语言环境：Python3.8

      深度学习环境：Pytorch

一.前期工作

1.设置GPU

若是使用的是cpu可忽略，不用管

import tensorflow as tf
gpus = tf.config.list_physical_devices("GPU")
 
if gpus:
    gpu0 = gpus[0]
    tf.config.experimental.set_memory_growth(gpu0, True)
    tf.config.set_visible_devices([gpu0],"GPU")

2.导入数据集

import matplotlib.pyplot as plt
import pathlib, PIL, warnings
import tensorflow as tf
# 用来设置中文字体，此处为黑体
plt.rcParams['font.sans-serif'] = ['SimHei']
# 用来显示负号
plt.rcParams['axes.unicode_minus'] = False
# 隐藏警告
warnings.filterwarnings('ignore')
 
# 导入数据
path = 'E:/TF环境/T8_data'
data_dir = pathlib.Path(path)
 
# 显示数据
image_count = len(list(data_dir.glob('*/*')))
print('图片总数为',image_count)

二、数据预处理

1、加载数据

使用image_dataset_from_directory方法将我们本地的数据加载到tf.data.Dataset中，并设置训练图片模型参数：划分训练集及验证集

train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    label_mode = "categorical",
    seed = 123,
    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 = 123,
    image_size = (img_height, img_width),
    batch_size = batch_size
)

# 查看数据
for image_batch, labels_batch in train_ds:
    print(image_batch.shape)
    print(labels_batch.shape)
    break

三、构建VGG-16网络

1. VGG优缺点分析

• VGG优点：
  -VGG的结构非常简洁，整个网络都使用了同样大小的卷积核尺寸（3x3）和最大池化尺寸（2x2）

• VGG缺点:
  -训练时间过长，调参难度大
  -需要的存储容量大，不利于部署。例如存储VGG-16权重值文件的大小为500多MB，不利于安装到嵌入式系统中

2. VGG结构说明

• 13个卷积层（Convolutional Layer），分别用 blockXconvX 表示
• 3个全连接层（Fully connected Layer），分别用fcX与predictions表示
• 5个池化层（Pool layer），分别用blockXpool表示

因为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)
    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)
    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)
    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)
    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)
    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)
    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.compile(
    optimizer='adam',
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=['accuracy']
)

• 13个卷积层(Convolutional Layer)，分别用blockx_conv×表示
• 3个全连接层（Fully connected Layer)，分别用fcx 与predictions表示·
• 5个池化层(Pool layer)，分别用blockx_pool 表示
  VGG-16包含了16个隐藏层（13个卷积层和3个全连接层)，故称为VGG-16

评论

VGG16结构，包含多个卷积层、池化层和全连接层。

• 第1个块：
  卷积层1：64个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block1_conv1'。
  卷积层2：64个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block1_conv2'。
  最大池化层：2x2大小的池化窗口，步幅为2，命名为'block1_pool'。
• 第2个块：
  卷积层1：128个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block2_conv1'。
  卷积层2：128个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block2_conv2'。
  最大池化层：2x2大小的池化窗口，步幅为2，命名为'block2_pool'。
• 第3个块：
  卷积层1：256个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block3_conv1'。
  卷积层2：256个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block3_conv2'。
  卷积层3：256个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block3_conv3'。
  最大池化层：2x2大小的池化窗口，步幅为2，命名为'block3_pool'。
• 第4个块：
  卷积层1：512个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block4_conv1'。
  卷积层2：512个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block4_conv2'。
  卷积层3：512个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block4_conv3'。
  最大池化层：2x2大小的池化窗口，步幅为2，命名为'block4_pool'。
• 第5个块：
  卷积层1：512个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block5_conv1'。
  卷积层2：512个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block5_conv2'。
  卷积层3：512个3x3大小的卷积核，使用ReLU激活函数，填充方式为"same"，命名为'block5_conv3'。
  最大池化层：2x2大小的池化窗口，步幅为2，命名为'block5_pool'。
• 全连接层部分：
  展平层：将多维输入展平为一维。
  全连接层1：具有4096个神经元，使用ReLU激活函数，命名为'fc1'。
  全连接层2：具有4096个神经元，使用ReLU激活函数，命名为'fc2'。

五、模型训练

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)
    with tqdm(total=train_total, desc=f'Epoch{epoch + 1}/{epoch}', mininterval=1, ncols=100) as pbar:
        lr = lr * 0.92
        k.set_value(model.optimizer.lr, lr)
 
        for image, label in train_ds:
            history = model.train_on_batch(image, label)
 
            train_loss = history[0]
            train_accuracy = history[1]
            pbar.set_postfix({'loss': '%.4f' % train_loss,
                              'accuracy': '%.4f' % train_accuracy,
                              'lr': k.get_value(model.optimizer.lr)}
                             )
            pbar.update(1)
        history_train_loss.append(train_loss)
        history_train_accuracy.append(train_accuracy)
    print('开始验证！')
    with tqdm(total=val_total, desc=f'Epoch{epoch + 1}/{epoch}', mininterval=0.3, ncols=100) as pbar:
        for image, label in val_ds:
            history = model.test_on_batch(image, label)
 
            val_loss = history[0]
            val_accuracy = history[1]
            pbar.set_postfix({'loss': '%.4f' % val_loss,
                              'accuracy': '%.4f' % val_accuracy}
                             )
            pbar.update(1)
        history_val_loss.append(val_loss)
        history_val_accuracy.append(val_accuracy)
    print('结束验证')
    print('验证loss为：%.4f' % val_loss)
    print('验证准确率为：%.4f' % val_accuracy)

六、模型评估

epochs_range = range(epochs)
 
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, history_train_loss, 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()

七、预测

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