优化器详解

# 1.优化器
# 损失函数调用backward方法，就可以调用损失函数的反向传播方法，
# 就可以求出我们需要调节的梯度，我们就可以利用我们的优化器就可以根据梯度对参数进行调整，达到整体误差降低的目的。
# 梯度要清零，如果梯度不清零会导致梯度累加。
import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

# 2.神经网络优化一轮
dataset = torchvision.datasets.CIFAR10(root='D:\PyCharm\CIFAR10', train=False,
                                       transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)


class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.model = nn.Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

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


model_1 = MyModel()
loss = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model_1.parameters(), lr=0.01)  # 随机梯度下降优化器
for data in dataloader:
    imgs, targets = data
    outputs_1 = model_1(imgs)
    result_loss_1 = loss(outputs_1, targets)  # 计算实际输出与目标输出的差距
    optimizer.zero_grad()  # 梯度清零
    result_loss_1.backward()  # 反向传播，计算损失函数的梯度
    optimizer.step()  # 根据梯度，对网络的参数进行调优
    print(result_loss_1)  # 因为对数据只看了一遍，只看了一轮，所以loss下降不大

# 3.神经网络优化多轮
model_2 = MyModel()
loss = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model_2.parameters(), lr=0.01)  # 随机梯度下降优化器
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs_2 = model_2(imgs)
        result_loss_2 = loss(outputs_2, targets)  # 计算实际输出与目标输出的差距
        optimizer.zero_grad()  # 梯度清零
        result_loss_2.backward()  # 反向传播，计算损失函数的梯度
        optimizer.step()  # 根据梯度，对网络的参数进行调优
        running_loss = running_loss + result_loss_2
    print(running_loss)  # 这一轮所以误差的总和

# 4.神经网络学习率优化
model_3 = MyModel()
loss = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model_3.parameters(), lr=0.01)  # 随机梯度下降优化器
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5,
                                            gamma=0.1)  # 每过 step_size 更新一次优化器，更新后的学习率为原来的学习率的的 0.1 倍
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs_3 = model_3(imgs)
        result_loss_3 = loss(outputs_3, targets)  # 计算实际输出与目标输出的差距
        optimizer.zero_grad()  # 梯度清零
        result_loss_3.backward()  # 反向传播，计算损失函数的梯度
        optimizer.step()  # 根据梯度，对网络的参数进行调优
        scheduler.step()  # 对学习率进行优化
        # 因为学习率太小了，所以20个轮次后，相当于没走多少
        running_loss = running_loss + result_loss_3
    print(running_loss) # 这一轮所以误差的总和