PyTorch学习笔记（12）--神经网络优化器

PyTorch学习笔记（12）–神经网络优化器

    本博文是PyTorch的学习笔记，第12次内容记录，主要是在上一篇文章中提到的损失函数的基础上，研究神经网络优化器的使用方法。

1.优化器是什么

    神经网络的学习的目的就是寻找合适的参数，使得损失函数的值尽可能小。解决这个问题的过程为称为最优化。解决这个问题使用的算法叫做优化器。在PyTorch官网中，将优化器放置在torch.optim中，并详细介绍了各种优化器的使用方法。

2.优化器的使用

2.1SGD优化器的使用

    现以CIFAR10数据集为例，损失函数选取交叉熵函数，优化器选择SGD优化器，搭建神经网络，并计算其损失值，用优化器优化各个参数，使其朝梯度下降的方向调整，完整代码如下：

# coding ：UTF-8
# 文件功能： 代码实现神经网络优化器的使用
# 开发人员： dpp
# 开发时间： 2021/8/18 4:52 下午
# 文件名称： nn_optim.py
# 开发工具： PyCharm

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("CIFAR10", train=False,
                                       transform=torchvision.transforms.ToTensor(), download=True)

dataloader = DataLoader(dataset, batch_size=1)

class Test(nn.Module):
    def __init__(self):
        super(Test, self).__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

test = Test()
loss = nn.CrossEntropyLoss()
optim = torch.optim.SGD(test.parameters(), lr=0.01)
for data in dataloader:
    imgs, targets = data
    outputs = test(imgs)
    result_loss = loss(outputs, targets)
    optim.zero_grad()   # 将上一轮的每个参数的梯度清零，必须做的，否则梯度计算会出问题
    result_loss.backward()  # 进行反向传播 并计算每个参数的梯度值
    optim.step()    # 对每个参数进行调优
    print(result_loss)

    上述代码中有关键的几行需要解释一下：
（1）optim = torch.optim.SGD(test.parameters(), lr=0.01)是在构建SGD优化器，其中的参数test.parameters()表示：待优化参数的iterable或者是定义了参数组的dict；lr=0.01表示学习率，一开始学习率一般设置为0.01。
（2）optim.zero_grad()是将上一轮计算的梯度清零，这一步是必须要做，否则上一轮的梯度值会影响下一轮的梯度值计算。
（3）result_loss.backward()是反向传播过程，与之前的forward()前向传播相反，在反向传播过程中会计算每个参数的梯度值。
（4） optim.step()：所有的optimizer都实现了step()方法，这个方法会更新所有的参数。
    上述代码的输出结果如下所示：

tensor(2.3462, grad_fn=<NllLossBackward>)
tensor(2.2783, grad_fn=<NllLossBackward>)
tensor(2.1884, grad_fn=<NllLossBackward>)
tensor(2.3619, grad_fn=<NllLossBackward>)
tensor(2.2983, grad_fn=<NllLossBackward>)
tensor(2.2581, grad_fn=<NllLossBackward>)
...

    观察上述完整的结果，发现损失函数值并没有明显的下降趋势，这是因为上述代码只进行了一次训练，因此想要损失函数值有明显的下降趋势，要进行多轮训练才行。

2.2使用SGD优化器进行多轮训练

    设置epoch，让其执行20次，并将每一次完整的训练的损失函数值求和输出，完整代码如下：

# coding ：UTF-8
# 文件功能： 代码实现神经网络优化器的使用
# 开发人员： dpp
# 开发时间： 2021/8/18 4:52 下午
# 文件名称： nn_optim.py
# 开发工具： PyCharm

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("CIFAR10", train=False,
                                       transform=torchvision.transforms.ToTensor(), download=True)

dataloader = DataLoader(dataset, batch_size=1)

class Test(nn.Module):
    def __init__(self):
        super(Test, self).__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

test = Test()
loss = nn.CrossEntropyLoss()
optim = torch.optim.SGD(test.parameters(), lr=0.01)
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = test(imgs)
        result_loss = loss(outputs, targets)
        optim.zero_grad()   # 将上一轮的每个参数的梯度清零，必须做的，否则梯度计算会出问题
        result_loss.backward()  # 进行反向传播 并计算每个参数的梯度值
        optim.step()    # 对每个参数进行调优
        running_loss = running_loss + result_loss
    print(running_loss)

    运行上述代码，得到如下结果，损失函数值呈现出下降的趋势。

tensor(18698.8438, grad_fn=<AddBackward0>)
tensor(16183.4062, grad_fn=<AddBackward0>)
tensor(15517.0400, grad_fn=<AddBackward0>)
...

3.学习小结

    在本文重点讲解了优化器的使用，并用一个实际的例子训练了神经网络，用到了SGD优化器，在一下一篇博文，将介绍现有网络模型的使用和修改方法。