第T6周：好莱坞明星识别

>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/Nb93582M_5usednAKp_Jtw) 中的学习记录博客**
>- **🍦 参考文章：365天深度学习训练营-第6周：好莱坞明星识别（训练营内部成员可读）**
>- **🍖 原作者：[K同学啊 | 接辅导、项目定制](https://mtyjkh.blog.csdn.net/)**
>- **🚀 文章来源：[K同学的学习圈子](https://www.yuque.com/mingtian-fkmxf/zxwb45)**

目录

一、前期工作

1. 设置GPU

2. 导入数据

3. 查看数据

知识点：

二、数据预处理

1. 加载数据

1.1 函数的基本用法：

1.2 加载数据代码

2. 可视化数据

知识点：

3. 再次检查数据

4. 配置数据集

三、构建CNN网络

知识点：

四、训练模型

1.设置动态学习率

损失函数Loss详解：

2.早停与保存最佳模型参数

ModelCheckpoint：

EarlyStopping()参数说明：

训练代码：

3. 模型训练

五、模型评估

1. Loss与Accuracy图

知识点：

2. 指定图片进行预测

六、使用VGG-16

1.加载数据

2.搭建VGG-16网络框架

3.使用VGG-16算法训练该模型

4.Loss与Accuracy图

---

一、前期工作

1. 设置GPU

如果使用的是CPU可以忽略这步

from tensorflow       import keras
from tensorflow.keras import layers,models
import os, PIL, pathlib
import matplotlib.pyplot as plt
import tensorflow        as tf
import numpy             as np

gpus = tf.config.list_physical_devices("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")
    
gpus

2. 导入数据

data_dir = "./48-data/"

data_dir = pathlib.Path(data_dir)

3. 查看数据

知识点：

• pathlib.Path的glob()方法

• • 使用 glob 方法来搜索与特定模式匹配的文件。在这里，模式为 */*.jpg，它会匹配 data_dir 目录及其子目录中所有扩展名为 ".jpg" 的文件。

• PIL.Image.open函数：

• • image = Image.open(image_path)
  • 可以将上面的image_path替换为要打开的文件路径

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

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

roses = list(data_dir.glob('Jennifer Lawrence/*.jpg'))
PIL.Image.open(str(roses[0]))

二、数据预处理

1. 加载数据

• 使用image_dataset_from_directory方法将磁盘中的数据加载到tf.data.Dataset中

• • tf.keras.preprocessing.image_dataset_from_directory 是 TensorFlow 的 Keras 模块中的一个函数，用于从目录中创建一个图像数据集（dataset）。这个函数可以以更方便的方式加载图像数据，用于训练和评估神经网络模型。

1.1 函数的基本用法：

创建出的数据集的标签一般是从目录得到的：

• directory: 数据所在目录。如果标签是inferred（默认），则它应该包含子目录，每个目录包含一个类的图像。否则，将忽略目录结构。
• labels: inferred（标签从目录结构生成），或者是整数标签的列表/元组，其大小与目录中找到的图像文件的数量相同。标签应根据图像文件路径的字母顺序排序（通过Python中的os.walk(directory)获得）。

import tensorflow as tf

# 设置图像数据目录
data_dir = "path/to/your/image/directory"

# 创建图像数据集
dataset = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    batch_size=32,  # 每个批次的图像数量
    image_size=(128, 128),  # 图像将被调整为的尺寸
    shuffle=True,  # 是否在每个 epoch 后对数据集进行洗牌
    seed=42,  # 洗牌时使用的随机种子
    validation_split=0.2,  # 验证集的比例
    subset="training"  # 使用训练集还是验证集，"training" 或 "validation"
)

# 查看类别标签
class_names = dataset.class_names
print("类别标签:", class_names)

# 可以通过迭代数据集来获取批次的图像和标签
for images, labels in dataset:
    # 在这里进行模型训练或评估操作
    pass

1.2 加载数据代码

batch_size = 32
img_height = 224
img_width = 224

label_mode:

• int：标签将被编码成整数（使用的损失函数应为：sparse_categorical_crossentropy loss）。
• categorical：标签将被编码为分类向量（使用的损失函数应为：categorical_crossentropy loss）。

"""
关于image_dataset_from_directory()的详细介绍可以参考文章：https://mtyjkh.blog.csdn.net/article/details/117018789
"""
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.1,
    subset="training",
    label_mode = "categorical",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)

"""
关于image_dataset_from_directory()的详细介绍可以参考文章：https://mtyjkh.blog.csdn.net/article/details/117018789
"""
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.1,
    subset="validation",
    label_mode = "categorical",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)

我们可以通过class_names输出数据集的标签。标签将按字母顺序对应于目录名称。

class_names = train_ds.class_names
print(class_names)

2. 可视化数据

知识点：

• 在 TensorFlow 中，take() 方法用于从数据集中获取指定数量的批次（或样本）。该方法返回一个新的数据集，其中包含了原始数据集中指定数量的批次。
• take(1)表示获取第一个批次的数据

plt.figure(figsize=(20, 10))

for images, labels in train_ds.take(1):
    for i in range(20):
        ax = plt.subplot(5, 10, i + 1)

        plt.imshow(images[i].numpy().astype("uint8"))
        plt.title(class_names[np.argmax(labels[i])])
        
        plt.axis("off")

3. 再次检查数据

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

• Image_batch是形状的张量（32,224,224,3）。这是一批形状224x224x3的32张图片（最后一维指的是彩色通道RGB）。
• Label_batch是形状（32，）的张量，这些标签对应32张图片

4. 配置数据集

• shuffle() ：打乱数据，关于此函数的详细介绍可以参考：数据集shuffle方法中buffer_size的理解 - 知乎
• prefetch() ：预取数据，加速运行

AUTOTUNE = tf.data.AUTOTUNE

train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

三、构建CNN网络

卷积神经网络（CNN）的输入是张量 (Tensor) 形式的 (image_height, image_width, color_channels)，包含了图像高度、宽度及颜色信息。不需要输入batch size。color_channels 为 (R,G,B) 分别对应 RGB 的三个颜色通道（color channel）。在此示例中，我们的 CNN 输入的形状是 (224, 224, 3)即彩色图像。我们需要在声明第一层时将形状赋值给参数input_shape。

知识点：

• layers.experimental.preprocessing.Rescaling 是 TensorFlow 2.x 中的一个图像预处理层（preprocessing layer），用于将图像的像素值重新缩放到指定的范围内。通常，在训练深度学习模型时，对输入数据进行标准化和缩放是一个常见的步骤，以便更好地训练模型并提高收敛速度。
• Rescaling 层通常用于模型的输入层，以确保输入数据的范围在合理的范围内。这对于训练深度学习模型非常重要，因为标准化和缩放可以改善梯度下降的性能，提高模型的稳定性和收敛速度。

"""
layers.Dropout(0.4) 作用是防止过拟合，提高模型的泛化能力。
"""

model = models.Sequential([
    layers.experimental.preprocessing.Rescaling(1./255, input_shape=(img_height, img_width, 3)),
    
    layers.Conv2D(16, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)), # 卷积层1，卷积核3*3  
    layers.AveragePooling2D((2, 2)),               # 池化层1，2*2采样
    layers.Conv2D(32, (3, 3), activation='relu'),  # 卷积层2，卷积核3*3
    layers.AveragePooling2D((2, 2)),               # 池化层2，2*2采样
    layers.Dropout(0.5),  
    layers.Conv2D(64, (3, 3), activation='relu'),  # 卷积层3，卷积核3*3
    layers.AveragePooling2D((2, 2)),     
    layers.Dropout(0.5),  
    layers.Conv2D(128, (3, 3), activation='relu'),  # 卷积层3，卷积核3*3
    layers.Dropout(0.5), 
    
    layers.Flatten(),                       # Flatten层，连接卷积层与全连接层
    layers.Dense(128, activation='relu'),   # 全连接层，特征进一步提取
    layers.Dense(len(class_names))               # 输出层，输出预期结果
])

model.summary()  # 打印网络结构

四、训练模型

在准备对模型进行训练之前，还需要再对其进行一些设置。以下内容是在模型的编译步骤中添加的：

• 损失函数（loss）：用于衡量模型在训练期间的准确率。
• 优化器（optimizer）：决定模型如何根据其看到的数据和自身的损失函数进行更新。
• 指标（metrics）：用于监控训练和测试步骤。以下示例使用了准确率，即被正确分类的图像的比率。

1.设置动态学习率

📮 ExponentialDecay函数：

tf.keras.optimizers.schedules.ExponentialDecay是 TensorFlow 中的一个学习率衰减策略，用于在训练神经网络时动态地降低学习率。学习率衰减是一种常用的技巧，可以帮助优化算法更有效地收敛到全局最小值，从而提高模型的性能。

🔎 主要参数：

• initial_learning_rate（初始学习率）：初始学习率大小。
• decay_steps（衰减步数）：学习率衰减的步数。在经过 decay_steps 步后，学习率将按照指数函数衰减。例如，如果 decay_steps 设置为 10，则每10步衰减一次。
• decay_rate（衰减率）：学习率的衰减率。它决定了学习率如何衰减。通常，取值在 0 到 1 之间。
• staircase（阶梯式衰减）：一个布尔值，控制学习率的衰减方式。如果设置为 True，则学习率在每个 decay_steps 步之后直接减小，形成阶梯状下降。如果设置为 False，则学习率将连续衰减。

# 设置初始学习率
initial_learning_rate = 1e-4

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
        initial_learning_rate, 
        decay_steps=60,      # 敲黑板！！！这里是指 steps，不是指epochs
        decay_rate=0.96,     # lr经过一次衰减就会变成 decay_rate*lr
        staircase=True)

# 将指数衰减学习率送入优化器
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

model.compile(optimizer=optimizer,
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

损失函数Loss详解：

1. binary_crossentropy（对数损失函数）

与 sigmoid 相对应的损失函数，针对于二分类问题。

2. categorical_crossentropy（多分类的对数损失函数）

与 softmax 相对应的损失函数，如果是one-hot编码，则使用 categorical_crossentropy

3. sparse_categorical_crossentropy（稀疏性多分类的对数损失函数）

与 softmax 相对应的损失函数，如果是整数编码，则使用 sparse_categorical_crossentropy

补充：

1. Sparse Categorical Crossentropy:

• • 通常用于多类别分类问题，其中每个样本属于一个类别。
  • 输入数据通常是整数标签，不需要进行独热编码（one-hot encoding）。
  • 适用于输出层使用softmax激活函数的情况，输出层神经元的数量等于类别数量。

1. Binary Crossentropy:

• • 通常用于二元分类问题，其中每个样本只能属于两个类别中的一个。
  • 输入数据通常是二元标签（0或1），表示样本属于某个类别或不属于它。
  • 适用于输出层只有一个神经元，并且使用sigmoid激活函数的情况。

1. Categorical Crossentropy:

• • 通常用于多类别分类问题，其中每个样本可以同时属于多个类别。
  • 输入数据通常是独热编码（one-hot encoding）的标签，表示每个样本的类别分布。
  • 适用于输出层使用softmax激活函数的情况，输出层神经元的数量等于类别数量。

2.早停与保存最佳模型参数

ModelCheckpoint：

• tensorflow.keras.callbacks.ModelCheckpoint 是 TensorFlow的一个回调函数（callback），用于在训练深度学习模型时定期保存模型的权重。这个回调函数允许在训练过程中选择性地保存模型的权重，以便在训练过程中的不同阶段或在训练结束后使用这些权重进行推断或继续训练。
• 当训练过程中的验证损失降低时，ModelCheckpoint 将自动保存模型的权重到指定的文件路径。

以下是 ModelCheckpoint 的基本参数示例：

from tensorflow.keras.callbacks import ModelCheckpoint

# 定义一个 ModelCheckpoint 回调函数
checkpoint = ModelCheckpoint(
    filepath='model_weights.h5',  # 保存模型权重的文件路径
    monitor='val_loss',           # 监控的指标，通常选择验证集上的损失
    save_best_only=True,          # 仅保存在监控指标上性能最佳的模型权重
    save_weights_only=True,       # 仅保存权重而不保存整个模型
    mode='min',                   # 监控模式，'min'表示损失越低越好
    verbose=1                      # 控制输出信息的详细程度，1为详细输出
)

EarlyStopping()参数说明：

• monitor: 被监测的数据。
• min_delta: 在被监测的数据中被认为是提升的最小变化， 例如，小于 min_delta 的绝对变化会被认为没有提升。
• patience: 没有进步的训练轮数，在这之后训练就会被停止。
• verbose: 详细信息模式。
• mode: {auto, min, max} 其中之一。 在 min 模式中， 当被监测的数据停止下降，训练就会停止；在 max 模式中，当被监测的数据停止上升，训练就会停止；在 auto 模式中，方向会自动从被监测的数据的名字中判断出来。
• baseline: 要监控的数量的基准值。 如果模型没有显示基准的改善，训练将停止。
• estore_best_weights: 是否从具有监测数量的最佳值的时期恢复模型权重。 如果为 False，则使用在训练的最后一步获得的模型权重。

训练代码：

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

epochs = 100

# 保存最佳模型参数
checkpointer = ModelCheckpoint('best_model.h5',
                                monitor='val_accuracy',
                                verbose=1,
                                save_best_only=True,
                                save_weights_only=True)

# 设置早停
earlystopper = EarlyStopping(monitor='val_accuracy', 
                             min_delta=0.001,
                             patience=20, 
                             verbose=1)

3. 模型训练

history = model.fit(train_ds,
                    validation_data=val_ds,
                    epochs=epochs,
                    callbacks=[checkpointer, earlystopper])

五、模型评估

1. Loss与Accuracy图

知识点：

• plt.legend 是 Matplotlib 库中的一个函数，用于在图形中添加图例（legend）。图例是一个标识，通常用来说明不同数据系列或曲线的含义，以帮助观众理解图形中的数据。
• 其中的loc 参数用于指定图例的位置。将 loc 参数设置为 'lower right'，图例被放在图形的右下角。

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(len(loss))

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

2. 指定图片进行预测

# 加载效果最好的模型权重
model.load_weights('best_model.h5')

from PIL import Image
import numpy as np

img = Image.open("./48-data/Jennifer Lawrence/003_963a3627.jpg")  #这里选择你需要预测的图片
image = tf.image.resize(img, [img_height, img_width])

img_array = tf.expand_dims(image, 0) 

predictions = model.predict(img_array) # 这里选用你已经训练好的模型
print("预测结果为：",class_names[np.argmax(predictions)])

六、使用VGG-16

使用VGG-16搭建模型后，验证集准确率基本在50%以上，提升了20多个点。

1.加载数据

调整图片尺寸，224x224------256x256

batch_size = 32
img_height = 256
img_width = 256

"""
关于image_dataset_from_directory()的详细介绍可以参考文章：https://mtyjkh.blog.csdn.net/article/details/117018789
"""
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.1,
    subset="training",
    label_mode = "categorical",
    seed=123,
    image_size=(img_height, img_width),
    batch_size=batch_size)

"""
关于image_dataset_from_directory()的详细介绍可以参考文章：https://mtyjkh.blog.csdn.net/article/details/117018789
"""
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.1,
    subset="validation",
    label_mode = "categorical",
    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

AUTOTUNE = tf.data.AUTOTUNE

train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds   = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

normalization_layer = layers.experimental.preprocessing.Rescaling(1./255)

train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
val_ds   = val_ds.map(lambda x, y: (normalization_layer(x), y))

image_batch, labels_batch = next(iter(val_ds))
first_image = image_batch[0]

# 查看归一化后的数据
print(np.min(first_image), np.max(first_image))

2.搭建VGG-16网络框架

from tensorflow.keras import layers, models, Input
from tensorflow.keras import regularizers
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout, BatchNormalization

# 在VGG16中，为减少过拟合风险，通常的做法是在全连接层之后添加 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 = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv2')(x)
    x = BatchNormalization()(x)  # 添加BN层
    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 = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv2')(x)
    x = BatchNormalization()(x)  # 添加BN层
    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 = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv2')(x)
    x = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv3')(x)
    x = BatchNormalization()(x)  # 添加BN层
    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 = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv2')(x)
    x = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv3')(x)
    x = BatchNormalization()(x)  # 添加BN层
    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 = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv2')(x)
    x = BatchNormalization()(x)  # 添加BN层
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv3')(x)
    x = BatchNormalization()(x)  # 添加BN层
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block5_pool')(x)
    # full connection
    x = Flatten()(x)
    x = Dense(4096, activation='relu', kernel_regularizer=regularizers.l2(0.1),  name='fc1')(x)
    x = Dropout(0.4)(x)  # 添加Dropout层
    x = Dense(4096, activation='relu', kernel_regularizer=regularizers.l2(0.1),  name='fc2')(x)
    x = Dropout(0.4)(x)  # 添加Dropout层
    output_tensor = Dense(nb_classes, activation='softmax', name='predictions')(x)

    model = Model(input_tensor, output_tensor)
    return model

model=VGG16(len(class_names), (img_width, img_height, 3)) 
model.summary()

3.使用VGG-16算法训练该模型

initial_learning_rate = 1e-4

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate,
    decay_steps=60,
    decay_rate=0.96,
    staircase=True
)

optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

model.compile(optimizer=optimizer,
             loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
             metrics=['accuracy'])

epochs = 30

history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=epochs
)

4.Loss与Accuracy图

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(len(loss))

plt.figure(figsize=(12, 4))

plt.subplot(1,2,1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()