P5学习笔记

无涯学徒1998

已于 2024-04-11 22:32:23 修改

阅读量1.1k

点赞数 26

文章标签： python pytorch

于 2024-04-11 22:32:13 首次发布

本文链接：https://blog.csdn.net/Inface0443/article/details/137655995

版权

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

运动鞋品牌识别

设置GPU
导入数据
构建CNN模型
编写训练函数
编写测试函数
设置动态学习率
正式训练
结果可视化
使用模型进行预测
个人总结

设置GPU

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets

import os,PIL,pathlib

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

device

device(type='cuda')

导入数据

import os,PIL,random,pathlib

data_dir = r'C:\Users\11054\Desktop\kLearning\p5_learning\data'
data_dir = pathlib.Path(data_dir)

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

['test', 'train']

# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
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] 从数据集中随机抽样计算得到的。
])

test_transform = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    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] 从数据集中随机抽样计算得到的。
])

train_dataset = datasets.ImageFolder(r'C:\Users\11054\Desktop\kLearning\p5_learning\data\train',transform=train_transforms)
test_dataset  = datasets.ImageFolder(r'C:\Users\11054\Desktop\kLearning\p5_learning\data\test',transform=test_transform)

train_dataset.class_to_idx

{'adidas': 0, 'nike': 1}

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)

for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

构建CNN模型

import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(3, 12, kernel_size=5, padding=0), # 12*220*220
            nn.BatchNorm2d(12),
            nn.ReLU())

        self.conv2=nn.Sequential(
            nn.Conv2d(12, 12, kernel_size=5, padding=0), # 12*216*216
            nn.BatchNorm2d(12),
            nn.ReLU())

        self.pool3=nn.Sequential(
            nn.MaxPool2d(2))                              # 12*108*108

        self.conv4=nn.Sequential(
            nn.Conv2d(12, 24, kernel_size=5, padding=0), # 24*104*104
            nn.BatchNorm2d(24),
            nn.ReLU())

        self.conv5=nn.Sequential(
            nn.Conv2d(24, 24, kernel_size=5, padding=0), # 24*100*100
            nn.BatchNorm2d(24),
            nn.ReLU())

        self.pool6=nn.Sequential(
            nn.MaxPool2d(2))                              # 24*50*50

        self.dropout = nn.Sequential(
            nn.Dropout(0.2))

        self.fc=nn.Sequential(
            nn.Linear(24*50*50, len(classeNames)))

    def forward(self, x):

        batch_size = x.size(0)
        x = self.conv1(x)  # 卷积-BN-激活
        x = self.conv2(x)  # 卷积-BN-激活
        x = self.pool3(x)  # 池化
        x = self.conv4(x)  # 卷积-BN-激活
        x = self.conv5(x)  # 卷积-BN-激活
        x = self.pool6(x)  # 池化
        x = self.dropout(x)
        x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 24*50*50) ==> (batch, -1), -1 此处自动算出的是24*50*50
        x = self.fc(x)

        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

model = Model().to(device)
model

Using cuda device





Model(
  (conv1): Sequential(
    (0): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
    (1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (conv2): Sequential(
    (0): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
    (1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (pool3): Sequential(
    (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (conv4): Sequential(
    (0): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
    (1): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (conv5): Sequential(
    (0): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
    (1): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
  )
  (pool6): Sequential(
    (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dropout): Sequential(
    (0): Dropout(p=0.2, inplace=False)
  )
  (fc): Sequential(
    (0): Linear(in_features=60000, out_features=2, bias=True)
  )
)

编写训练函数

# 训练循环
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

def adjust_learning_rate(optimizer, epoch, start_lr):
    # 每 2 个epoch衰减到原来的 0.98
    lr = start_lr * (0.98 ** (epoch // 2))
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

设置动态学习率

learn_rate = 0.001# 初始学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)

等间隔动态调整

torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。StepLR 调度器将会修改该优化器的学习率。
step_size（必需参数）：表示学习率下降的周期数。当训练周期的数量达到 step_size 的倍数时，学习率将按照 gamma 的值进行降低。例如，如果 step_size 为 30，那么学习率将在第 30、60、90，以及之后的周期进行降低。
gamma（必需参数）：衰减因子，用于指定学习率下降的倍数。在每个周期结束时，学习率将乘以 gamma 的值以降低学习率。通常，gamma 的值是小于 1 的浮点数，以降低学习率，例如，0.1 表示学习率减小为原来的 10%。
last_epoch（可选参数，默认为 -1）：这个参数表示最后一个训练周期的索引。如果不提供此参数，它会被初始化为 -1，然后在每次学习率更新后自动递增。

# scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.13)

自定义调整

torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1, verbose=False)

optimizer(Optimizer)：是之前定义好的需要优化的优化器的实例名
lr_lambda(function)：更新学习率的函数

lambda1 = lambda epoch: (0.98 ** (epoch // 2) )# 第二组参数的调整方法
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) #选定调整方法

多间隔调整

torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。MultiStepLR 调度器将会修改该优化器的学习率。
milestones（必需参数）：这是一个列表，其中包含了一系列训练周期的索引，学习率在这些周期结束时会降低。例如，如果 milestones 是 [30, 50, 80]，那么学习率将在第 30、50、80 个周期结束时降低。
gamma（可选参数，默认为 0.1）：衰减因子，用于指定学习率下降的倍数。在每个里程碑处，学习率将乘以 gamma 的值以降低学习率。通常，gamma 的值是小于 1 的浮点数，以降低学习率，例如，0.1 表示学习率减小为原来的 10%。
last_epoch（可选参数，默认为 -1）：这个参数表示最后一个训练周期的索引。如果不提供此参数，它会被初始化为 -1，然后在每次学习率更新后自动递增。

# scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
#                                                  milestones=[2,4,7], #调整学习率的epoch数
#                                                  gamma=0.2)

余弦退火

torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。CosineAnnealingLR 调度器将会修改该优化器的学习率。
T_max（必需参数）：这是一个整数，表示学习率在一个周期内变化的次数。一个完整的周期是指学习率从最大值开始下降到 eta_min（下面介绍）再上升到最大值的过程。T_max 决定了一个完整周期的长度。
eta_min（可选参数，默认为 0）：这是学习率在一个周期内的最小值，通常是一个小的非负数。学习率将在一个周期内从最大值下降到 eta_min，然后再上升到最大值。这有助于避免学习率过小，从而防止训练提前停止或陷入局部最小值。
last_epoch（可选参数，默认为 -1）：这个参数表示最后一个训练周期的索引。如果不提供此参数，它会被初始化为 -1，然后在每次学习率更新后自动递增。

# T_max = 20  # 完整周期长度
# scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)

正式训练

loss_fn    = nn.CrossEntropyLoss() #交叉熵函数作为损失函数
epochs     = 80

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

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)

    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))
print('Done')

Epoch:74, Train_acc:100.0%, Train_loss:0.020, Test_acc:76.3%, Test_loss:0.729, Lr:4.83E-04
Epoch:75, Train_acc:99.6%, Train_loss:0.020, Test_acc:76.3%, Test_loss:0.644, Lr:4.74E-04
Epoch:76, Train_acc:100.0%, Train_loss:0.017, Test_acc:76.3%, Test_loss:0.804, Lr:4.74E-04
Epoch:77, Train_acc:99.6%, Train_loss:0.032, Test_acc:75.0%, Test_loss:0.758, Lr:4.64E-04
Epoch:78, Train_acc:99.4%, Train_loss:0.029, Test_acc:75.0%, Test_loss:0.715, Lr:4.64E-04
Epoch:79, Train_acc:100.0%, Train_loss:0.016, Test_acc:78.9%, Test_loss:0.681, Lr:4.55E-04
Epoch:80, Train_acc:99.8%, Train_loss:0.019, Test_acc:76.3%, Test_loss:0.659, Lr:4.55E-04
Done
Epoch: 1, Train_acc:51.2%, Train_loss:3.526, Test_acc:55.3%, Test_loss:0.974, Lr:1.00E-03
Epoch: 2, Train_acc:53.2%, Train_loss:2.163, Test_acc:56.6%, Test_loss:1.180, Lr:1.00E-03
Epoch: 3, Train_acc:63.3%, Train_loss:1.196, Test_acc:65.8%, Test_loss:0.692, Lr:9.80E-04
Epoch: 4, Train_acc:62.7%, Train_loss:1.044, Test_acc:64.5%, Test_loss:0.773, Lr:9.80E-04
Epoch: 5, Train_acc:72.5%, Train_loss:0.649, Test_acc:56.6%, Test_loss:1.283, Lr:9.60E-04
Epoch: 6, Train_acc:77.5%, Train_loss:0.526, Test_acc:52.6%, Test_loss:1.334, Lr:9.60E-04
Epoch: 7, Train_acc:79.5%, Train_loss:0.462, Test_acc:61.8%, Test_loss:0.839, Lr:9.41E-04
Epoch: 8, Train_acc:85.5%, Train_loss:0.342, Test_acc:77.6%, Test_loss:0.451, Lr:9.41E-04
Epoch: 9, Train_acc:82.3%, Train_loss:0.361, Test_acc:73.7%, Test_loss:0.576, Lr:9.22E-04
Epoch:10, Train_acc:94.0%, Train_loss:0.186, Test_acc:76.3%, Test_loss:0.415, Lr:9.22E-04
Epoch:11, Train_acc:94.4%, Train_loss:0.168, Test_acc:76.3%, Test_loss:0.392, Lr:9.04E-04
Epoch:12, Train_acc:96.4%, Train_loss:0.151, Test_acc:84.2%, Test_loss:0.363, Lr:9.04E-04
Epoch:13, Train_acc:96.8%, Train_loss:0.126, Test_acc:86.8%, Test_loss:0.334, Lr:8.86E-04
Epoch:14, Train_acc:98.0%, Train_loss:0.113, Test_acc:80.3%, Test_loss:0.428, Lr:8.86E-04
Epoch:15, Train_acc:97.6%, Train_loss:0.113, Test_acc:85.5%, Test_loss:0.299, Lr:8.68E-04
Epoch:16, Train_acc:97.4%, Train_loss:0.101, Test_acc:86.8%, Test_loss:0.320, Lr:8.68E-04
Epoch:17, Train_acc:99.0%, Train_loss:0.088, Test_acc:84.2%, Test_loss:0.365, Lr:8.51E-04
Epoch:18, Train_acc:99.2%, Train_loss:0.074, Test_acc:86.8%, Test_loss:0.367, Lr:8.51E-04
Epoch:19, Train_acc:99.4%, Train_loss:0.078, Test_acc:84.2%, Test_loss:0.300, Lr:8.34E-04
Epoch:20, Train_acc:99.6%, Train_loss:0.064, Test_acc:84.2%, Test_loss:0.405, Lr:8.34E-04
Epoch:21, Train_acc:99.8%, Train_loss:0.061, Test_acc:84.2%, Test_loss:0.329, Lr:8.17E-04
Epoch:22, Train_acc:99.6%, Train_loss:0.066, Test_acc:85.5%, Test_loss:0.316, Lr:8.17E-04
Epoch:23, Train_acc:99.6%, Train_loss:0.059, Test_acc:80.3%, Test_loss:0.473, Lr:8.01E-04
Epoch:24, Train_acc:99.4%, Train_loss:0.052, Test_acc:84.2%, Test_loss:0.275, Lr:8.01E-04
Epoch:25, Train_acc:99.8%, Train_loss:0.049, Test_acc:86.8%, Test_loss:0.307, Lr:7.85E-04
Epoch:26, Train_acc:99.6%, Train_loss:0.048, Test_acc:85.5%, Test_loss:0.321, Lr:7.85E-04
Epoch:27, Train_acc:100.0%, Train_loss:0.044, Test_acc:85.5%, Test_loss:0.290, Lr:7.69E-04
Epoch:28, Train_acc:99.8%, Train_loss:0.048, Test_acc:86.8%, Test_loss:0.302, Lr:7.69E-04
Epoch:29, Train_acc:100.0%, Train_loss:0.046, Test_acc:85.5%, Test_loss:0.308, Lr:7.54E-04
Epoch:30, Train_acc:100.0%, Train_loss:0.042, Test_acc:85.5%, Test_loss:0.296, Lr:7.54E-04
Epoch:31, Train_acc:100.0%, Train_loss:0.036, Test_acc:86.8%, Test_loss:0.305, Lr:7.39E-04
Epoch:32, Train_acc:100.0%, Train_loss:0.036, Test_acc:86.8%, Test_loss:0.358, Lr:7.39E-04
Epoch:33, Train_acc:99.8%, Train_loss:0.035, Test_acc:86.8%, Test_loss:0.352, Lr:7.24E-04
Epoch:34, Train_acc:100.0%, Train_loss:0.034, Test_acc:84.2%, Test_loss:0.349, Lr:7.24E-04
Epoch:35, Train_acc:100.0%, Train_loss:0.032, Test_acc:86.8%, Test_loss:0.314, Lr:7.09E-04
Epoch:36, Train_acc:100.0%, Train_loss:0.035, Test_acc:86.8%, Test_loss:0.372, Lr:7.09E-04
Epoch:37, Train_acc:100.0%, Train_loss:0.031, Test_acc:84.2%, Test_loss:0.341, Lr:6.95E-04
Epoch:38, Train_acc:100.0%, Train_loss:0.027, Test_acc:85.5%, Test_loss:0.347, Lr:6.95E-04
Epoch:39, Train_acc:100.0%, Train_loss:0.030, Test_acc:85.5%, Test_loss:0.386, Lr:6.81E-04
Epoch:40, Train_acc:100.0%, Train_loss:0.028, Test_acc:86.8%, Test_loss:0.290, Lr:6.81E-04
Epoch:41, Train_acc:100.0%, Train_loss:0.028, Test_acc:85.5%, Test_loss:0.394, Lr:6.68E-04
Epoch:42, Train_acc:100.0%, Train_loss:0.025, Test_acc:86.8%, Test_loss:0.329, Lr:6.68E-04
Epoch:43, Train_acc:100.0%, Train_loss:0.027, Test_acc:85.5%, Test_loss:0.426, Lr:6.54E-04
Epoch:44, Train_acc:100.0%, Train_loss:0.025, Test_acc:86.8%, Test_loss:0.282, Lr:6.54E-04
Epoch:45, Train_acc:100.0%, Train_loss:0.024, Test_acc:85.5%, Test_loss:0.347, Lr:6.41E-04
Epoch:46, Train_acc:100.0%, Train_loss:0.023, Test_acc:85.5%, Test_loss:0.304, Lr:6.41E-04
Epoch:47, Train_acc:100.0%, Train_loss:0.022, Test_acc:86.8%, Test_loss:0.294, Lr:6.28E-04
Epoch:48, Train_acc:100.0%, Train_loss:0.024, Test_acc:86.8%, Test_loss:0.391, Lr:6.28E-04
Epoch:49, Train_acc:100.0%, Train_loss:0.022, Test_acc:84.2%, Test_loss:0.342, Lr:6.16E-04
Epoch:50, Train_acc:100.0%, Train_loss:0.023, Test_acc:85.5%, Test_loss:0.378, Lr:6.16E-04
Epoch:51, Train_acc:100.0%, Train_loss:0.021, Test_acc:85.5%, Test_loss:0.319, Lr:6.03E-04
Epoch:52, Train_acc:100.0%, Train_loss:0.019, Test_acc:85.5%, Test_loss:0.311, Lr:6.03E-04
Epoch:53, Train_acc:100.0%, Train_loss:0.021, Test_acc:85.5%, Test_loss:0.279, Lr:5.91E-04
Epoch:54, Train_acc:100.0%, Train_loss:0.021, Test_acc:84.2%, Test_loss:0.311, Lr:5.91E-04
Epoch:55, Train_acc:100.0%, Train_loss:0.021, Test_acc:84.2%, Test_loss:0.379, Lr:5.80E-04
Epoch:56, Train_acc:100.0%, Train_loss:0.020, Test_acc:85.5%, Test_loss:0.347, Lr:5.80E-04
Epoch:57, Train_acc:100.0%, Train_loss:0.020, Test_acc:85.5%, Test_loss:0.382, Lr:5.68E-04
Epoch:58, Train_acc:100.0%, Train_loss:0.020, Test_acc:85.5%, Test_loss:0.313, Lr:5.68E-04
Epoch:59, Train_acc:100.0%, Train_loss:0.020, Test_acc:84.2%, Test_loss:0.350, Lr:5.57E-04
Epoch:60, Train_acc:100.0%, Train_loss:0.018, Test_acc:84.2%, Test_loss:0.322, Lr:5.57E-04
Epoch:61, Train_acc:100.0%, Train_loss:0.018, Test_acc:85.5%, Test_loss:0.299, Lr:5.45E-04
Epoch:62, Train_acc:100.0%, Train_loss:0.020, Test_acc:84.2%, Test_loss:0.302, Lr:5.45E-04
Epoch:63, Train_acc:100.0%, Train_loss:0.017, Test_acc:84.2%, Test_loss:0.492, Lr:5.35E-04
Epoch:64, Train_acc:100.0%, Train_loss:0.017, Test_acc:84.2%, Test_loss:0.397, Lr:5.35E-04
Epoch:65, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.309, Lr:5.24E-04
Epoch:66, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.354, Lr:5.24E-04
Epoch:67, Train_acc:100.0%, Train_loss:0.017, Test_acc:84.2%, Test_loss:0.325, Lr:5.13E-04
Epoch:68, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.354, Lr:5.13E-04
Epoch:69, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.391, Lr:5.03E-04
Epoch:70, Train_acc:100.0%, Train_loss:0.018, Test_acc:84.2%, Test_loss:0.360, Lr:5.03E-04
Epoch:71, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.345, Lr:4.93E-04
Epoch:72, Train_acc:100.0%, Train_loss:0.017, Test_acc:84.2%, Test_loss:0.316, Lr:4.93E-04
Epoch:73, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.303, Lr:4.83E-04
Epoch:74, Train_acc:100.0%, Train_loss:0.015, Test_acc:84.2%, Test_loss:0.361, Lr:4.83E-04
Epoch:75, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.326, Lr:4.74E-04
Epoch:76, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%, Test_loss:0.393, Lr:4.74E-04
Epoch:77, Train_acc:100.0%, Train_loss:0.015, Test_acc:84.2%, Test_loss:0.350, Lr:4.64E-04
Epoch:78, Train_acc:100.0%, Train_loss:0.015, Test_acc:84.2%, Test_loss:0.310, Lr:4.64E-04
Epoch:79, Train_acc:99.8%, Train_loss:0.017, Test_acc:85.5%, Test_loss:0.294, Lr:4.55E-04
Epoch:80, Train_acc:100.0%, Train_loss:0.015, Test_acc:84.2%, Test_loss:0.331, Lr:4.55E-04
Done

结果可视化

import matplotlib.pyplot as plt
#隐藏警告
import warnings
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()

在这里插入图片描述

使用模型进行预测

from PIL import Image

classes = list(train_dataset.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)
    pred_class = classes[pred]
    print(f'预测结果是：{pred_class}')

# 预测训练集中的某张照片
predict_one_image(image_path=r'C:\Users\11054\Desktop\kLearning\p5_learning\data\test\adidas\0.jpg',
                  model=model,
                  transform=train_transforms,
                  classes=classes)

预测结果是：nike

# 模型保存
PATH = r'C:\Users\11054\Desktop\kLearning\p5_learning\model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))