T9:猫狗识别2-优快云博客

本文链接：https://blog.youkuaiyun.com/apwpasy/article/details/144250345

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

我的环境
语言环境：python 3.7.12
编译器：pycharm
深度学习环境：tensorflow 2.7.0
数据：本地数据集

🍺 要求：

找到并处理第8周的程序问题（本文给出了答案）

🍻 拔高（可选）：
2. 请尝试增加数据增强部分内容以提高准确率
3. 可以使用哪些方式进行数据增强？（下一周给出了答案）

🔎 探索（难度有点大）
4. 本文中的代码存在较大赘余，请对代码进行精简

一、总结

T8的错误

变量覆盖：
在每次迭代中，train_loss 和 train_accuracy 都会被重新赋值为当前 batch 的损失和准确率。
由于这些变量是单个标量，而不是列表或数组，因此它们不会累积每个 batch 的值，而是每次都直接覆盖为最新的值
当 epoch 结束时
history_train_loss.append(train_loss) 和 history_train_accuracy.append(train_accuracy) 会将最后一个 batch 的损失和准确率添加到 history_train_loss 和 history_train_accuracy 列表中。
这意味着，无论你在 epoch 中有多少个 batch，最终记录的损失和准确率都只反映了最后一个 batch 的表现，而忽略了其他所有 batch 的信息。
会造成的问题
指标波动较大：由于只记录了最后一个 batch 的损失和准确率，可能会导致指标波动较大，尤其是在 batch 之间的损失和准确率差异较大的情况下。最后一个 batch 的表现可能并不能代表整个 epoch 的总体表现。
无法反映整体趋势：如果你关心的是整个 epoch 的总体表现，这种方式可能会导致误判。例如，如果最后一个 batch 的数据分布与之前的 batch 不同，或者该 batch 的样本数量较少，那么它的损失和准确率可能并不具有代表性。
不稳定的学习过程：如果你使用这些指标来监控模型的训练过程（例如通过早停或学习率调度器），基于最后一个 batch 的指标可能会导致不稳定的决策，因为它们可能并不是模型的真实表现。

for image, label in train_ds:
    history = model.train_on_batch(image, label)

    train_loss = history[0]  # 每次迭代时，train_loss 被覆盖为当前 batch 的损失
    train_accuracy = history[1]  # 每次迭代时，train_accuracy 被覆盖为当前 batch 的准确率
    
    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)  # epoch 结束时，记录的是最后一个 batch 的损失
history_train_accuracy.append(train_accuracy)  # epoch 结束时，记录的是最后一个 batch 的准确率

T9的代码就这一问题进行了更正：
在这里插入图片描述

二、实验过程

2.1代码

import tensorflow as tf

gpus = tf.config.list_physical_devices("GPU")

if gpus:
    tf.config.experimental.set_memory_growth(gpus[0], True)  #设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpus[0]],"GPU")

# 打印显卡信息，确认GPU可用
print(gpus)

import numpy as np
import matplotlib.pyplot as plt
# 支持中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

import os,PIL,pathlib

#隐藏警告
import warnings
warnings.filterwarnings('ignore')

data_dir = "./365-9-data"
data_dir = pathlib.Path(data_dir)

image_count = len(list(data_dir.glob('*/*')))

print("图片总数为：",image_count)

batch_size = 64
img_height = 224
img_width  = 224

"""
关于image_dataset_from_directory()的详细介绍可以参考文章：https://mtyjkh.blog.youkuaiyun.com/article/details/117018789
"""
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)

"""
关于image_dataset_from_directory()的详细介绍可以参考文章：https://mtyjkh.blog.youkuaiyun.com/article/details/117018789
"""
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)

class_names = train_ds.class_names
print(class_names)

for image_batch, labels_batch in train_ds:
    print(image_batch.shape)
    print(labels_batch.shape)
    break

AUTOTUNE = tf.data.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)

plt.figure(figsize=(15, 10))  # 图形的宽为15高为10

for images, labels in train_ds.take(1):
    for i in range(10):
        # ax = plt.subplot(5, 10, i + 1) # 5*10的子图网络
        ax = plt.subplot(2, 5, i + 1) # 1*10的子图网络
        plt.imshow(images[i])
        plt.title(class_names[labels[i]])
        plt.axis("off")

    plt.show()
    

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.compile(optimizer="adam",
              loss     ='sparse_categorical_crossentropy',
              metrics  =['accuracy'])

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

epochs_range = range(epochs)

plt.figure(figsize=(14, 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()

import numpy as np

# 采用加载的模型（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")