15.nn_optim

https://pytorch.org/docs/stable/optim.html

优化器用于神经网络参数进行更新，在backward后使用，要注意的是，每次backward前都要进行清零。

Example：

for input, target in dataset:
    optimizer.zero_grad()#梯度清零
    output = model(input)
    loss = loss_fn(output, target)#计算损失
    loss.backward()#反向传播，计算loss对各个参数的grad
    optimizer.step()#优化器参数更新

我们在：梯度清零，方向传播，参数更新处设置三个断点进行debug

demo/Protected Attributes/modules/model/Protected Attributes/modules/2 (查看第二个卷积层处的参数)

debug，梯度清零 （因为是第一个循环，所以grad初始值为0）

debug，backward，计算出梯度

debug，参数更新，data中的参数开始更新

for循环执行完一轮后，参数变化不够，训练时必须进行多个epoch。

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Linear, Flatten
from torch.utils.data import DataLoader
dataset = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset,batch_size=1)
class DEMO(nn.Module):
    def __init__(self):
        super(DEMO, self).__init__()
        self.model = nn.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(in_features=1024, out_features=64),
            Linear(in_features=64, out_features=10),
        )
    def forward(self,x):
        x = self.model(x)
        return x
demo = DEMO()
loss_cross = nn.CrossEntropyLoss()
optim = torch.optim.SGD(demo.parameters(),lr= 0.01)
# range(2), 也就是两个epoch，epoch会执行 0 1  而不是 0 1 2
for epoch in range(2):
    running_loss = 0.0
    for data in dataloader:
        imgs,targets = data
        output = demo(imgs)
        # print(output)    output神经网络输出的一组得分（不是概率）
        # print(targets)   target就是目标
        loss = loss_cross(output,targets)
        optim.zero_grad()
        loss.backward()
        optim.step()
        running_loss = running_loss + loss
    print(running_loss) # 每个epoch的总损失
    print("epoch =",epoch+1)
print('ok')