优化器的学习--torch.optim

优化器的作用是依据梯度更新权重参数，包括随机梯度下降法SGD, AdaGrad方法等
迭代时使用优化器的步骤：
1、定义优化器  torch.optim.类（参数）
2（关键）、将优化器的参数清0   类名.zero_grad()方法
3、反向传播
4、进行优化计算，更新权重和偏置参数 类名.step()方法

以下定义了一个简单卷积神经网络，采用随机梯度下降法进行了20轮的迭代更新，期间统计了所有样本在每一轮的误差。

# 优化器的作用是依据梯度更新权重参数，包括随机梯度下降法SGD, AdaGrad方法等
# 迭代时使用优化器的步骤：
# 1、定义优化器  torch.optim.类（参数）
# 2（关键）、将优化器的参数清0   类名.zero_grad()方法
# 3、反向传播
# 4、进行优化计算，更新权重和偏置参数 类名.step()方法

import torch
import torch.nn as nn
import torchvision
from torch.utils.data import DataLoader
from torchvision import transforms


# 定义一个卷积网络
class My_nn_s(nn.Module):
    def __init__(self):
        super(My_nn_s, self).__init__()
        self.model = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
                                   nn.MaxPool2d(2),
                                   nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
                                   nn.MaxPool2d(2),
                                   nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
                                   nn.MaxPool2d(2),
                                   nn.Flatten(),
                                   nn.Linear(1024, 64),
                                   nn.Linear(64, 10)
                                   )

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


if __name__ == '__main__':
    # 以随机梯度下降法为例进行优化训练
    test_set = torchvision.datasets.CIFAR10('./dataset', train=False, transform=transforms.ToTensor(), download=True)

    data_loader = DataLoader(dataset=test_set, batch_size=64, shuffle=True, num_workers=0, drop_last=True)

    my_nn = My_nn_s()  # 实例化类
    loss_CE = nn.CrossEntropyLoss()  # 实例化损失函数
    optim = torch.optim.SGD(params=my_nn.parameters(), lr=0.01)  # 其他参数均默认

    for epoch in range(20):  # 进行20轮学习，每轮对所有测试集（数量比较少，仅作为演示）进行学习
        loss_all = 0.0  # 该参数统计每一轮的误差总和
        for data in data_loader:
            imgs, targets = data
            predict = my_nn(imgs)
            loss = loss_CE(predict, targets)
            optim.zero_grad()  # 对梯度进行初始化
            # 求解梯度
            loss.backward()  # 反向传播求解梯度
            optim.step()  # 使用优化器对梯度进行更新
            loss_all += loss
        print('第{}轮的误差为：{}'.format(epoch, loss_all))