第五周：使用PyTorch实现运动鞋识别

最新推荐文章于 2025-05-12 18:37:30 发布

oufoc

最新推荐文章于 2025-05-12 18:37:30 发布

阅读量1k

点赞数 36

分类专栏： 365深度学习训练营-PyTorch 文章标签： pytorch 人工智能 python

本文链接：https://blog.csdn.net/weixin_47918905/article/details/137751630

版权

365深度学习训练营-PyTorch 专栏收录该内容

10 篇文章

订阅专栏

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

文章目录

一、本周学习内容
二、前言
三、电脑环境
四、前期准备
1、导入相关依赖项，设置CPU
2、加载数据
3、数据可视化
4、划分数据集

五、搭建简单的CNN网络
六、训练模型
1、编写训练函数
2、编写测试函数
3、设置动态学习率
4、正式训练

七、结果可视化
1、Loss与Accuracy图
2. 指定图片进行预测

八、保存并加载模型
九、动态学习率
1. torch.optim.lr_scheduler.StepLR
2. lr_scheduler.LambdaLR
3.lr_scheduler.MultiStepLR

总结：

一、本周学习内容

1、了解如何设置动态学习率（重点）
2、保存训练过程中的最佳模型权重
3、调整代码使测试集accuracy到达86%。

二、前言

本次使用pytorch实现对运动鞋品牌的识别，标签分为两类：‘adidas’和’nike’。数据集下载地址：链接: link。

三、电脑环境

电脑系统：macOS Monterey 12.7.4
语言环境：Python 3.8.0
编译器：Jupyter Notebook
深度学习环境：torch：2.2.1 torchvision：0.17.1

四、前期准备

1、导入相关依赖项，设置CPU

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

2、加载数据

import os,PIL,random,pathlib

data_dir = './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’]

3、数据可视化

import matplotlib.pyplot as plt
from PIL import Image

# 指定图像文件夹路径
image_folder = './data/train/nike/'

image_files = [f for f in os.listdir(image_folder) if f.endswith((".jpg", ".png", ".jpeg"))]

fig, axes = plt.subplots(3, 8, figsize=(16, 6))

for ax, img_file in zip(axes.flat, image_files):
    img_path = os.path.join(image_folder, img_file)
    img = Image.open(img_path)
    ax.imshow(img)
    ax.axis('off')

plt.tight_layout()
plt.show()

在这里插入图片描述
图形变换操作：

# 关于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("./data/train/",transform=train_transforms)
test_dataset  = datasets.ImageFolder("./data/test/",transform=train_transforms)

将数据集类别映射为数字索引：

数据集有两个类别：adidas和nike。

train_dataset.class_to_idx

输出为：

{‘adidas’: 0, ‘nike’: 1}

4、划分数据集

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),
            nn.BatchNorm2d(12),
            nn.ReLU()
        )

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

        self.conv3 = nn.Sequential(
            nn.Conv2d(24, 24, kernel_size=5, padding=0),
            nn.BatchNorm2d(24),
            nn.ReLU()
        )

        self.conv4 = nn.Sequential(
            nn.Conv2d(24, 48, kernel_size=5, padding=0),
            nn.BatchNorm2d(48),
            nn.ReLU()
        )

        self.conv5 = nn.Sequential(
            nn.Conv2d(48, 48, kernel_size=5, padding=0),
            nn.BatchNorm2d(48),
            nn.ReLU()
        )

        self.conv6 = nn.Sequential(
            nn.Conv2d(48, 96, kernel_size=5, padding=0),
            nn.BatchNorm2d(96),
            nn.ReLU()
        )

        self.pool = nn.Sequential(
            nn.MaxPool2d(2)
        )


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

        self.fc1 = nn.Sequential(
            nn.Linear(96*47*47, len(classeNames))
        )

        
    def forward(self, x):
        batch_size = x.size(0)
        x = self.conv1(x)    # 224 -> 220
        x = self.conv2(x)    # 220 -> 216
        x = self.conv3(x)    # 216 -> 212
        x = self.pool(x)     # 212 -> 106
        x = self.conv4(x)    # 106 -> 102
        x = self.conv5(x)    # 102 -> 98
        x = self.conv6(x)    # 98 -> 94
        x = self.pool(x)     # 94 -> 47
        x = self.dropout(x)
        x = x.view(batch_size, -1)
        x = self.fc1(x)
        return x

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

model = Model().to(device)
model

六、训练模型

1、编写训练函数

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    train_acc, train_loss = 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()       # 每一步自动更新

        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

2、编写测试函数

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)

            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

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

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

3、设置动态学习率

def adjust_learning_rate(optimizer, epoch, start_lr):
    # 每 2 个epoch衰减到原来的 0.92
    lr = start_lr * (0.92 ** (epoch // 2))
    # 遍历优化器中的所有参数组，并将每个参数组的学习率设置为新计算出的 lr。
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

learn_rate = 1e-4 # 初始学习率
optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)

✨调用官方动态学习率接口，与上面方法是等价的：

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

4、正式训练

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

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

输出结果：
在这里插入图片描述

七、结果可视化

1、Loss与Accuracy图

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

2. 指定图片进行预测

torch.squeeze()函数和torch.unsqueeze()函数在之前的文章中有介绍。

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

从adidas文件夹随机选一张图片进行预测：

# 预测训练集中的某张照片
predict_one_image(image_path='./data/test/adidas/1.jpg', 
                  model=model, 
                  transform=train_transforms, 
                  classes=classes)

输出：

预测结果是：adidas

八、保存并加载模型

# 模型保存
PATH = './model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

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

九、动态学习率

1. torch.optim.lr_scheduler.StepLR

等间隔动态调整方法，每经过step_size个epoch，做一次学习率decay，以gamma值为缩小倍数。

函数原型：

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

关键参数详解：

optimizer(Optimizer)：是之前定义好的需要优化的优化器的实例名
step_size(int)：是学习率衰减的周期，每经过每个epoch，做一次学习率decay
gamma(float)：学习率衰减的乘法因子。Default：0.1

用法示例：

optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

2. lr_scheduler.LambdaLR

根据自己定义的函数更新学习率。

函数原型：

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

关键参数详解：

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

用法示例：

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

3.lr_scheduler.MultiStepLR

在特定的 epoch 中调整学习率

函数原型：

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

关键参数详解：

optimizer(Optimizer)：是之前定义好的需要优化的优化器的实例名
milestones(list)：是一个关于epoch数值的list，表示在达到哪个epoch范围内开始变化，必须是升序排列
gamma(float)：学习率衰减的乘法因子。Default：0.1

用法示例：

optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[2,6,15], #调整学习率的epoc数
gamma=0.1)

更多的官方动态学习率设置方式可参考：https://pytorch.org/docs/stable/optim.html

👉调用官方接口示例：

model = [Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler = ExponentialLR(optimizer, gamma=0.9)

for epoch in range(20):
    for input, target in dataset:
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
    scheduler.step()