笔者PyTorch的全部简单教程请访问：https://www.jianshu.com/nb/48831659

PyTorch教程-3：PyTorch中神经网络的构建与训练基础

基本原理

在PyTorch中定义一个网络模型，需要让自定义的网络类继承自 torch.nn.Module，并且比较重要的是需要重写其 forward 方法，也就是对网络结构的前向传播做出定义，即在forward方法中，需要定义一个输入变量 input 是如何经过哪些运算得到输出结果的。这样，当一个网络作用于输入变量后，就能得到输出的值（output = MyNet(input)）。然后通过计算损失（loss），也就是网络的预测值与真实值之间的差距，再将这个损失反向传播，loss.backward() 就可以计算得到loss对网络中所有参数的反向传播后的梯度值，这里的backward就是依赖于forward定义的运算规则而自动计算的。最后在利用梯度值来更新网络的参数从而完成一步训练。

大体来说，训练一个网路通常需要经理如下的步骤：

• 定义网络结构以及其中要学习的参数
• 从数据库获取输入值
• 将输入值输入网络得到输出值
• 计算输出值与标签之间的loss
• 将loss做反向传播求得loss之于所有参数的导数
• 更新参数，比如SGD的更新方式：weight_new = weights_old − learning_rate × gradient

本文使用一个最简单的LeNet为例，该网络的输入是一个 32×32 大小的单通道灰度图，输出为 10 个分类的值（1×10的向量），具有两个卷积层（与池化层），三个全连接层（与激发函数）。

1.png

input -> (convolution -> acrivate function ->pooling) * 2 -> (fully-connection -> activate function) * 2 -> fully-connection -> output

定义网络

定义网路的类要继承自 torch.nn.Module，并且必须至少重写 forward 方法来定义网络结构，只要定义了forward函数，autograd的backward方法可以自动完成。torch.nn 模块中定义了很多定义网络的常用层、函数，而 torch.nn.functional 模块中则定义了很多网络中常用的函数，这里给出了一个定义LeNet的例子，其中用到了常用的卷积层、池化层、全连接层、激活函数等：

import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()

        # convolution layers
        self.conv1 = nn.Conv2d(1,6,3)
        self.conv2 = nn.Conv2d(6,16,3)

        # fully-connection layers
        self.fc1 = nn.Linear(16*6*6,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)

    def forward(self,x):
        # max pooling over convolution layers
        x = F.max_pool2d(F.relu(self.conv1(x)),2)
        x = F.max_pool2d(F.relu(self.conv2(x)),2)

        # fully-connected layers followed by activation functions
        x = x.view(-1,16*6*6)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))

        # final fully-connected without activation functon
        x = self.fc3(x)

        return x

net = Net()
print(net)

Net(
  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))
  (fc1): Linear(in_features=576, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

定义完成的网络，可以使用 parameters() 来获得其所有的参数：

parameters = list(net.parameters())
print(len(parameters))

10

向网络中输入值

定义完一个网络结果，接下来我们需要向网络中输入值，从而获得输出结果。
在PyTorch中，torch.nn仅支持mini-batches的类型，所以无法单独输入任何一个input，哪怕是一个输入也要包装成单个sample的batch，即batch-size设置为1。比如说上述网络的第一层是二维卷积从 nn.Conv2d，其实他接受的是一个四维tensor：样本数×通道数×高×宽。

对于一个单独的输入样本，可以通过使用 torch.Tensor.unsqueeze(dim) 或者 torch.unsqueeze(Tensor, dim) 实现。

• torch.Tensor.unsqueeze(dim)：为原来的tensor增加一个维度，返回一个新的tensor。其接受一个整数做参数，用于标示要增加的维度，比如0表示在第一维增加一维
• torch.unsqueeze(Tensor, dim)：将Tensor增加一个维度并返回新的tensor，第二个参数dim同上

下边是一个例子可以验证上述的方法，随机生成了一个 1×32×32 大小的tensor作为网络的输入，但是需要先提前将其包装成1个大小的batch（等同于直接生成一个随机的 1×1×32×32 大小的tensor）：

x = torch.rand(1,32,32)
print(x.size())
y = x.unsqueeze(0)
print(y.size())
z = torch.unsqueeze(x,0)
print(z.size())

torch.Size([1, 32, 32])
torch.Size([1, 1, 32, 32])
torch.Size([1, 1, 32, 32])

将一个单元素的batch喂给我们的网络并获取输出的例子：

x=torch.rand(1,1,32,32)
out = net(x)
print(out)

tensor([[-0.1213,  0.0420, -0.0926,  0.0741,  0.0615, -0.1131,  0.0136, -0.0526,
         -0.0172,  0.0244]], grad_fn=<AddmmBackward>)

计算损失（Loss）

网络的训练需要基于loss，也就是网络预测值与标签真实值之间的差距。nn.Module中同样定义了很多损失函数（loss function），可以直接使用，比如这里使用的平方平均值误差（mean-squared error）MSELoss。

已知我们获得的对于输入x的网络预测值为out，然后生成一个随机的label值（目标值）target（这里和输入值需要保持一致，因此1×10表示1是batch-size，10才是单个标签的大小），计算两个值的损失：

x=torch.rand(1,1,32,32)
out = net(x)
target = torch.rand(1,10)

loss_function = nn.MSELoss()
loss = loss_function(out,target)

print(loss)

tensor(0.3597, grad_fn=<MseLossBackward>)

反向传播

有了loss之后，我们就要通过反向传播计算loss对于每一个参数的导数，很简单，使用 loss.backward() 即可，因为loss就是对于所有参数进行了一定的计算后得到的一个单标量的tensor，且在计算过程中追踪记录了所有的操作。在进行反向传播前，不要忽略了使用 net.zero_grad() 将所有参数的梯度缓存置0。

net.zero_grad()

loss.backward()
print(net.conv1.bias.grad)

tensor([-0.0007,  0.0007, -0.0005,  0.0068,  0.0026,  0.0000])

更新参数

得到了每个参数的梯度，最后就是要更新这些参数，比如在随机梯度下降（Stochastic Gradient Descent，SGD）中的更新方法是：

weight_new = weights_old − learning_rate × gradient

直接写代码完成上述操作即：

lr = 0.01
for p in net.parameters():
    p.data.sub_(p.grad.data * lr)

当然，更好更快捷的方法就是使用PyTorch提供的包与已有的函数：使用 torch.optim 来完成，其中实现了很多常用的更新参数的方法，比如SGD，Adam，RMSProp等。使用optim中方法实例的step方法来进行一步参数更新。

import torch.optim as optim

optimizer = optim.SGD(net.parameters(),lr =0.01)

optimizer.zero_grad()
out = net(x)
loss = loss_function(out,target)
net.zero_grad()
loss.backward()
optimizer.step()

重要参考索引

我们涉及到的三个重要的torch包/模块，它们其中提供了大量的对于神经网络的方法，它们完整的参考列表如下（强烈建议过一遍）：