目录

1、本文内容：

1、内容：

2、简单介绍下VGG16：

3、相关其他模型也可以调用：

2、代码展示：

3、训练结果：

1、不同优化器：

①【使用SGD优化器】

②【使用Adam优化器】

③Adam + 动态学习率ExponentialLR

④Adam + 动态学习率ExponentialLR+ 降低初始学习率（lr=0.001）

⑤Adam+动态学习率LinearLR

⑥Adam+动态学习率LinearLR+ 降低c初始学习率（lr=0.001）

4、总结

---

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

1、本文内容：

1、内容：

这篇文章，主要是通过调用现有VGG16的模型，来完成人脸的预测。

这篇文章的亮点主要是提高测试集的精确度。

2、简单介绍下VGG16：

VGG-16的主要特点：
        1、深度：VGG-16 = 16个卷积层+3个全连接层组成 ，因此具有相对较深的网络结构。这种深度有助于网络学习到更加抽象和复杂的特征。
        2、卷积层的设计：VGG-16的卷积层全部采用3x3的卷积核和步长为1的卷积操作，同时在卷积层之后都有接ReLU激活函数。这种设计的好处在于，通过堆叠多个较小的卷积核，可以提高网络的非线性建模能力，同时减少了参数数量， 从而降低了过拟合的风险。
        3、池化层：在卷积层之后，VGG-16使用最大池化层来减少特征图的空间尺寸，帮助提取更加显著的特征并减少计算量。
        4、全连接层：VGG-16在卷积层之后接有3个全连接层，最后一个全连接层输出与类别数相对应的向量，用于进行分类。

VGG-16结构说明：
        13个卷积层，分别用blockX-convX表示
        3个全连接层，用classifier表示
        5个池化层。

3、相关其他模型也可以调用：

 Pytorch官网链接地址

2、代码展示：

import copy
import pathlib
import warnings

import matplotlib.pyplot as plt
import torch
from PIL import Image
from torch import nn
from torchvision import datasets
from torchvision.models import vgg16, VGG16_Weights
from torchvision.transforms import transforms
import matplotlib as mpl

mpl.use('Agg')  # 在服务器上运行的时候，打开注释

# 检查设备
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print(device)

# 1、导入数据
data_dir = './data'
data_dir = pathlib.Path(data_dir)
print(data_dir)

data_paths = list(data_dir.glob('*'))
classNames = [str(path).split('/')[1] for path in data_paths]

# 图像预处理
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

total_data = datasets.ImageFolder('./data', transform=train_transforms)

# 划分数据集
train_size = int(0.8 * len(total_data))
test_size = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
print(train_size, test_size)  # 1440  360

# 数据加载
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True)

for X, y in test_dl:
    print('Shape of X [N,C,H,W]:', X.shape)  # [32, 3, 224, 224]
    print('Shape of y:', y.shape, y.dtype)  # torch.Size([32]) torch.int64
    break

# 调用官方的VGG-16模型
"""
    VGG-16的主要特点：
        1、深度：VGG-16 = 16个卷积层+3个全连接层组成 ，因此具有相对较深的网络结构。这种深度有助于网络学习到更加抽象和复杂的特征。
        2、卷积层的设计：VGG-16的卷积层全部采用3x3的卷积核和步长为1的卷积操作，同时在卷积层之后都有接ReLU激活函数。
                      这种设计的好处在于，通过堆叠多个较小的卷积核，可以提高网络的非线性建模能力，同时减少了参数数量，
                      从而降低了过拟合的风险。
        3、池化层：在卷积层之后，VGG-16使用最大池化层来减少特征图的空间尺寸，帮助提取更加显著的特征并减少计算量。
        4、全连接层：VGG-16在卷积层之后接有3个全连接层，最后一个全连接层输出与类别数相对应的向量，用于进行分类。

    VGG-16结构说明：
        13个卷积层，分别用blockX-convX表示
        3个全连接层，用classifier表示
        5个池化层。
"""
# 加载预训练模型，并且对模型进行微调。
model = vgg16(weights=VGG16_Weights.DEFAULT).to(device)

for param in model.parameters():
    param.requires_grad = False  # 冻结模型参数，这样在训练的时候只训练最后一层的参数。

# print("原始模型：",model)
# 修改classifier模块的第6层。即：(6): Linear(in_features=4096, out_features=1000, bias=True)
model.classifier[6] = nn.Linear(4096, len(classNames))  # 修改vgg16 模型中最后一层全连接层，输出目标类别个数
model.to(device)


# print("改完后的模型：",model)


# 编写训练函数
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    train_loss, train_acc = 0, 0

    for X, y in dataloader:
        X, y = X.to(device), y.to(device)

        # 计算预测误差
        pred = model(X)
        loss = loss_fn(pred, y)

        # 反向传播
        optimizer.zero_grad()  # grad梯度归零
        loss.backward()  # 反向传播
        optimizer.step()  # 每一步自动更新

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss


# 编写测试函数
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    test_acc, test_loss = 0, 0

    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc /= size
    test_loss /= num_batches
    return test_acc, test_loss


# 设置动态学习率
learn_rate = 1e-4  # 初始学习率

# 调用官方动态学习率接口时使用：
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)  # 选定调整学习率的方法

# 正式训练
loss_fn = nn.CrossEntropyLoss()  # 创建损失函数
epochs = 40
train_loss = []
train_acc = []
test_loss = []
test_acc = []

best_acc = 0  # 设置一个最佳准确率，作为最佳模型的判别指标。
for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    scheduler.step()  # 用于更新学习率（调用官网动态学习率接口的时候，在这里使用）

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    # 保存最佳模型到best_model
    if epoch_test_acc > best_acc:
        best_acc = epoch_test_acc
        best_model = copy.deepcopy(model)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f},|||| Test_acc:{:.1f}%,Test_loss:{:.3f}, Lr:{:.2E}')
    print(
        template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))

# 保存最佳模型到文件中
PATH = './best_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)
print('Done')

# 结果可视化
warnings.filterwarnings('ignore')
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label="Training Accuracy")
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title("Training and Validation Accuracy")

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validataion Loss')
plt.savefig("/data/jupyter/deepinglearning_train_folder/p06_vgg16/resultImg.jpg")  # 保存图片在服务器的位置
plt.show()

# 指定图片进行预测
classes = list(total_data.class_to_idx)


def predict_one_image(image_path, model, transform, classes):
    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)

    model.eval()
    output = model(img)

    _, pred = torch.max(output, 1)
    print(_, pred)
    pred_class = classes[pred]
    print(f'预测结果：{pred_class}')


# 预测训练集中的某张照片
predict_one_image(image_path='./data/Angelina Jolie/001_fe3347c0.jpg', model=model, transform=train_transforms,
                  classes=classes)

# 评估模型
best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
print(f'模型评估：测试acc：{epoch_test_acc}-----测试Loss：{epoch_test_loss}')

3、训练结果：

1、不同优化器：

对比下，目前主流的两个优化器：SGD和Adam优化器。

①【使用SGD优化器】

测试精确度达到18%。

②【使用Adam优化器】

测试精确达到39%。

③Adam + 动态学习率ExponentialLR

测试精确度达到43%。

④Adam + 动态学习率ExponentialLR+ 降低初始学习率（lr=0.001）

测试精确度达到48%

⑤Adam+动态学习率LinearLR

测试精确度达到43%。

⑥Adam+动态学习率LinearLR+ 降低c初始学习率（lr=0.001）

测试精确度达到48%，最高可达到51%。

4、总结

①将SGD优化器换成Adam优化器，精确度会提升1倍。

②使用Adam+动态学习率（即：③、⑤，精度会再次提升。）

③使用③里的的配置，仅改变学习率（lr=1e-4→lr=1e-3），测试精度会再次提升，见④。

④使用⑤里的的配置，仅改变学习率（lr=1e-4→lr=1e-3），测试精度会再次提升，见⑥。

总结上述，测试精确度的提升，最大是优化器的改变、动态学习率、初始学习率的降低。

这些都会影响到模型的精确度。