第P6周：马铃薯病害识别（VGG-16复现）

?Agony

已于 2025-01-03 15:15:08 修改

阅读量602

点赞数 20

文章标签： pytorch 人工智能 python

于 2024-12-27 16:56:35 首次发布

本文链接：https://blog.youkuaiyun.com/e_motion/article/details/144771043

版权

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

一、导入库

在这里插入代码片import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings
import os,PIL,random,pathlib
import matplotlib.pyplot as plt
#隐藏警告
import warnings

二、导入数据

warnings.filterwarnings("ignore")             #忽略警告信息

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

data_dir = './data/48-data/'
data_dir = pathlib.Path(data_dir)

data_paths  = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[2] for path in data_paths]

['Angelina Jolie',
 'Brad Pitt',
 'Denzel Washington',
 'Hugh Jackman',
 'Jennifer Lawrence',
 'Johnny Depp',
 'Kate Winslet',
 'Leonardo DiCaprio',
 'Megan Fox',
 'Natalie Portman',
 'Nicole Kidman',
 'Robert Downey Jr',
 'Sandra Bullock',
 'Scarlett Johansson',
 'Tom Cruise',
 'Tom Hanks',
 'Will Smith']

三、格式对齐

train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    # transforms.RandomHorizontalFlip(), # 随机水平翻转
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
    mean=[0.485, 0.456, 0.406],
    std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

#将每个文件夹视为一个标签，然后将文件夹的名字作为标签名字
total_data = datasets.ImageFolder("./data/48-data/",transform=train_transforms)
#查看各个标签的序号
#print(total_data.class_to_idx)

四、划分数据集

#划分数据集
train_size = int(0.8 * len(total_data))  #训练集的长度是整个数据集的80%
test_size = len(total_data) - train_size #整个训练集的数量减去训练集的数量极速测试集的数量
# torch.utils.data.random_split是一个函数，它随机地将一个数据集分割成指定大小的多个子集。
# 第一个参数total_data是原始的数据集。
# 第二个参数[train_size, test_size]是一个列表，指定了每个子集的大小。这里，它创建了两个子集：一个训练集和一个测试集，它们的大小分别是train_size和test_size。
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
#设置批大小
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True,
                                          num_workers=1)

五、使用官方的VGG并微调

#调用官方VGG库
from torchvision.models import vgg16

# 加载预训练模型，并且对模型进行微调
model = vgg16(pretrained=True).to(device)  # 加载预训练的vgg16模型

#model.parameters()：这是一个生成器，它返回模型中所有参数（参数是指模型中的权重和偏置项）。这些参数通常是可训练的，意味着在模型训练过程中它们的值会根据梯度下降算法进行更新。
for param in model.parameters():
    #requires_grad：指示该参数是否需要计算梯度。如果设置为True，那么在反向传播过程中，PyTorch会自动计算并存储该参数的梯度，以便进行参数更新。如果设置为False，则不会计算该参数的梯度，因此在训练过程中不会更新该参数的值。
    param.requires_grad = False  # 冻结模型的参数，这样子在训练的时候只训练最后一层的参数

# 修改classifier模块的第6层（即：(6): Linear(in_features=4096, out_features=2, bias=True)）
# 注意查看我们下方打印出来的模型
#model.classifier:指模型的全连接层
#_modules:是一个字典，存储了所有模块的子模块
model.classifier._modules['6'] = nn.Linear(4096, len(classeNames))  # 修改vgg16模型中最后一层全连接层，输出目标类别个数
model.to(device)#将模型及其所有参数移动到指定的设备上
#print(model)

1. VGG介绍

VGG-16（Visual Geometry Group-16）是由牛津大学视觉几何组（Visual Geometry Group）提出的一种深度卷积神经网络架构，用于图像分类和对象识别任务。VGG-16在2014年被提出，是VGG系列中的一种。VGG-16之所以备受关注，是因为它在ImageNet图像识别竞赛中取得了很好的成绩，展示了其在大规模图像识别任务中的有效性。

以下是VGG-16的主要特点：

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

VGG-16结构说明：

● 13个卷积层（Convolutional Layer），分别用blockX_convX表示；
● 3个全连接层（Fully connected Layer），用classifier表示；
● 5个池化层（Pool layer）。

VGG-16包含了16个隐藏层（13个卷积层和3个全连接层），故称为VGG-16
在这里插入图片描述

六、创建训练函数

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)  # 批次数目, (size/batch_size，向上取整)

    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)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失

        # 反向传播
        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)  # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 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

八、设置动态学习率

#设置动态学习率，参考P5
learn_rate = 1e-4 # 初始学习率
# 调用官方动态学习率接口时使用
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
optimizer = torch.optim.Adam(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) #选定调整方法

九、设置主函数

import copy

loss_fn = nn.CrossEntropyLoss()  # 创建损失函数
epochs = 30

train_loss = []
train_acc = []
test_loss = []
test_acc = []

best_acc = 0  # 设置一个最佳准确率，作为最佳模型的判别指标

if __name__ == "__main__":
    for epoch in range(epochs):
        # 更新学习率（使用自定义学习率时使用）
        # adjust_learning_rate(optimizer, epoch, learn_rate)

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

Epoch: 1, Train_acc:12.2%, Train_loss:2.731, Test_acc:20.0%, Test_loss:2.491, Lr:1.00E-04
Epoch: 2, Train_acc:20.7%, Train_loss:2.418, Test_acc:23.3%, Test_loss:2.321, Lr:1.00E-04
Epoch: 3, Train_acc:25.6%, Train_loss:2.241, Test_acc:28.9%, Test_loss:2.215, Lr:1.00E-04
Epoch: 4, Train_acc:29.0%, Train_loss:2.126, Test_acc:30.6%, Test_loss:2.147, Lr:9.20E-05
Epoch: 5, Train_acc:35.8%, Train_loss:2.028, Test_acc:29.7%, Test_loss:2.088, Lr:9.20E-05
Epoch: 6, Train_acc:34.4%, Train_loss:1.965, Test_acc:32.5%, Test_loss:2.051, Lr:9.20E-05
Epoch: 7, Train_acc:38.9%, Train_loss:1.900, Test_acc:34.2%, Test_loss:2.013, Lr:9.20E-05
Epoch: 8, Train_acc:41.0%, Train_loss:1.850, Test_acc:35.8%, Test_loss:1.977, Lr:8.46E-05
Epoch: 9, Train_acc:41.8%, Train_loss:1.813, Test_acc:34.4%, Test_loss:1.976, Lr:8.46E-05
Epoch:10, Train_acc:43.1%, Train_loss:1.771, Test_acc:36.1%, Test_loss:1.945, Lr:8.46E-05
Epoch:11, Train_acc:45.3%, Train_loss:1.730, Test_acc:36.1%, Test_loss:1.927, Lr:8.46E-05
Epoch:12, Train_acc:44.7%, Train_loss:1.701, Test_acc:36.7%, Test_loss:1.902, Lr:7.79E-05
Epoch:13, Train_acc:47.2%, Train_loss:1.683, Test_acc:37.2%, Test_loss:1.881, Lr:7.79E-05
Epoch:14, Train_acc:48.5%, Train_loss:1.644, Test_acc:36.4%, Test_loss:1.863, Lr:7.79E-05
Epoch:15, Train_acc:48.9%, Train_loss:1.611, Test_acc:38.1%, Test_loss:1.861, Lr:7.79E-05
Epoch:16, Train_acc:50.1%, Train_loss:1.589, Test_acc:36.9%, Test_loss:1.846, Lr:7.16E-05
Epoch:17, Train_acc:51.8%, Train_loss:1.582, Test_acc:38.1%, Test_loss:1.848, Lr:7.16E-05
Epoch:18, Train_acc:52.8%, Train_loss:1.549, Test_acc:38.6%, Test_loss:1.844, Lr:7.16E-05
Epoch:19, Train_acc:51.8%, Train_loss:1.530, Test_acc:37.5%, Test_loss:1.847, Lr:7.16E-05
Epoch:20, Train_acc:51.1%, Train_loss:1.531, Test_acc:40.3%, Test_loss:1.807, Lr:6.59E-05
Epoch:21, Train_acc:53.6%, Train_loss:1.489, Test_acc:40.0%, Test_loss:1.816, Lr:6.59E-05
Epoch:22, Train_acc:54.9%, Train_loss:1.469, Test_acc:39.7%, Test_loss:1.792, Lr:6.59E-05
Epoch:23, Train_acc:56.2%, Train_loss:1.454, Test_acc:39.2%, Test_loss:1.804, Lr:6.59E-05
Epoch:24, Train_acc:56.0%, Train_loss:1.437, Test_acc:40.6%, Test_loss:1.772, Lr:6.06E-05
Epoch:25, Train_acc:58.2%, Train_loss:1.423, Test_acc:40.3%, Test_loss:1.775, Lr:6.06E-05
Epoch:26, Train_acc:57.0%, Train_loss:1.403, Test_acc:40.6%, Test_loss:1.762, Lr:6.06E-05
Epoch:27, Train_acc:57.6%, Train_loss:1.409, Test_acc:40.3%, Test_loss:1.751, Lr:6.06E-05
Epoch:28, Train_acc:59.4%, Train_loss:1.384, Test_acc:39.7%, Test_loss:1.780, Lr:5.58E-05
Epoch:29, Train_acc:59.0%, Train_loss:1.382, Test_acc:39.4%, Test_loss:1.782, Lr:5.58E-05
Epoch:30, Train_acc:57.8%, Train_loss:1.373, Test_acc:40.0%, Test_loss:1.759, Lr:5.58E-05
Done

十、可视化训练过程

这里使用的是训练集和测试集的真实值和损失值

    warnings.filterwarnings("ignore")               #忽略警告信息
    plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
    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 Validation Loss')
    plt.show()

在这里插入图片描述

十一、调用模型的权重然后预测图片

之前的模型存放在P6_VGG.py中，创建一个新的python文件，去调用模型文件，导入权重

import torch
import torchvision.transforms as transforms
from PIL import Image
import torch.nn as nn
from torchvision import models
import matplotlib.pyplot as plt
import P6_VGG as VGG

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

classes = list(VGG.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)  # 展示预测的图片
    plt.show()

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

    model.eval()
    output = model(img)

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

if __name__ == "__main__":
    predict_one_image(image_path='./data/48-data/Jennifer Lawrence/001_fe3347c0.jpg',
                  model=VGG.model,
                  transform=VGG.train_transforms,
                  classes=classes)

在这里插入图片描述

预测结果是：Jennifer Lawrence

心得

本次主要是调用了官方的VGG模块完成的实训，了解到VGG网络的架构非常统一，它由一系列的卷积层和池化层组成，卷积层的卷积核大小都是3x3，步长为1，池化层的池化大小为2x2，步长为2，这种统一的架构使得VGG网络易于理解和实现。本次还尝试了将模型和调用预测模块进行了分离，分成了两个文件实现的这一过程。但是观察结果不难发现准确率很低，所以下一步要尝试提高模型的准确率。