神经网络简介

原文：https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py

我们可以使用torch.nn工具包来构建神经网络。

前面我们已经学完了autograd自动求导引擎，nn引擎需要借助autograd模块来定义神经网络并对它们进行求导。一个nn.Module网络模型包含若干神经层，并且内置了一个forward(input)方法来完成前向传播计算并得到输出output。

举例来说，下面就是一个用于手写体分类的神经网络模型：

这是一个简单的前馈神经网络。它接受输入数据，并穿过若干网络层，最终得到输出结果。

一个典型的神经网络训练流程包含一下若干步骤：

• 定义一个含有若干可以学习参数（权重）的神经网络
• 遍历一个数据集，取出数据输入到网络当中
• 经过整个网络对输入数据进行计算
• 计算最终的loss值（输出值与理论值的误差）
• 反向传播梯度值到网络的参数当中
• 更新网络中的权重，例如一个简单的权重更新规则：weight = weight - learning_rat*gradient

创建一个神经网络

让我们来创建刚才讨论的神经网络：

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

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 3x3 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

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)
)

您只需要定义前向传播函数（forward），反向传播函数（backward通常用来计算梯度）会由autograd自动为您生成。您可以在前向传播函数（forward）中使用任意的张量操作。

网络模型中的可学习参数由net.parameters()方法得到：

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

显示：

10
torch.Size([6, 1, 3, 3])

我们来试下输入一个32x32的随机数。注意：该网络（LeNet）允许的输入数据维度是32x32。如果你想在此网络上训练MNIST数据集的话，需要将图像数据维度修改为32x32。

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

显示：

tensor([[ 0.1464,  0.0673, -0.0185,  0.0048,  0.1427, -0.0866, -0.0237, -0.0991, -0.0903,  0.0886]], grad_fn=<AddmmBackward>)

清空网络中的所有参数缓存而后反向传播随机梯度值。

net.zero_grad()
out.backward(torch.randn(1, 10))

注意：

torch.nn只支持小批量样本输入。整个torch.nn工具包只支持小批量样本格式，单个样本不能作为输入。

举例来说，nn.Conv2d卷积模块只接受4维张量作为输入：nSamples x nChannels x Height x Width。

如果你只有一个样本数据，可以使用input.unsqueeze(0)方法打包成4维张量。

在进一步学习之前，我们先来回顾一下目前为止学习到的pytorch类：
回顾：

• torch.Tensor - 一种多维的数据结构，支持autograd引擎的相关操作，例如backward()。同时也能够存储张量相关的梯度信息。
• nn.Module - 定义和管理神经网络模型。可以方便的存储参数，将模型导入到GPU进行运算，导出模型或者载入模型。
• nn.Parameter - 一种张量结构，当指定为Module属性时，会自动注册为参数。
• autograd.Function - autograd引擎进行前向传播和反向传播时所执行的计算操作。每个Tensor操作至少创建一个Function节点，该节点连接到创建张量并对其历史进行编码的函数。

到目前为止，我们已经学习了：

• 如何定义一个神经网络
• 如何处理输入数据和使用反向传播函数

剩下需要学习的部分：

• 如何计算损失值
• 如何更新整个网络参数

损失函数

损失函数将（网络最终输出值，目标值）作为输入，通过一定的计算规则来衡量二者之间的差距有多大。
在nn的工具包里已经有许多不同类型的损失函数。一个最简单的损失函数是：nn.MSELoss，全称叫均方差损失函数。它用来计算网络输出值与目标值之间的均方差。
举例来说：

output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

输出：

tensor(1.0942, grad_fn=<MseLossBackward>)

如果你跟随loss值按反向传播方向进行回溯，查看每个节点的.grad_fn属性，你将看到如下的计算图：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

所以当我们调用loss.backward()函数时，整个计算图中对应的张量将计算它们的梯度信息。整个loss值以及计算图中requires_grad=True的张量会将计算的梯度信息累加到对应张量的.grad信息中。
比如说，我们可以从根节点反向跟踪几个节点：

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

显示：

<MseLossBackward object at 0x7f191e0c39b0>
<AddmmBackward object at 0x7f191e0c3128>
<AccumulateGrad object at 0x7f191e0c3128>

反向传播

要进行反向传播计算我们仅需要调用loss.backward()。不过你首先需要清除已有的梯度信息，否则新的梯度信息会叠加到已有的梯度信息中去。
好了，我们现在调用loss.backward()方法，然后看下conv1层在调用反向传播前后的梯度信息变化。

net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

显示：

conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([-0.0068, -0.0244,  0.0278, -0.0142,  0.0111, -0.0078])

现在，我们已经完成了整套损失函数的使用流程。
扩展阅读：

神经网络工具包含有各种网络模块和损失函数，这些网络模块和损失函数构成了深度神经网络的基石。 带有文档的完整列表位于此处。

更新权重

最简单的权重更新规则是随机梯度下降（SGD）：
weight = weight - learning_rate * gradient
我们来用一点简单的Python代码实现它：

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

但是，当你开始使用神经网络时，你可能会想使用各种不同的权重更新方法，例如：SGD、Nesterov-SGD、Adam、RMSProp等等。为帮你达成此目的，我们打造了一个小的工具包：torch.optim来实现上述所有方法，使用它也非常简单：

import torch.optim as optim

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

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

注意：
观察梯度缓存是在何时手动调用optimizer.zero_grad()清0的，这是因为在之前反向传播小节我们提到过梯度信息会不断累加的。