【PyTorch入门】（三）神经网络（Neural Networks）

官网。更新于2019.06.13。

可以用torch.nn包构建神经网络。看完这篇文章应该对autograd有了一定的了解，nn是基于autograd定义和求导模型的。一个nn.Module包括层以及用于返回output的forward(input)方法。

比如，对于如下数字图像分类网络（convnet）：

这是一个简单的前向传播网络。给定输入后，传入几层级联的卷积层，最后给出输出。

一个典型的神经网络训练过程为：

• 定义含有可学习参数（或权重）的神经网络
• 在一个数据集下构成的输入中迭代
• 通过网络处理输入
• 计算损失（输出距离正确值有多远）
• 反向传递梯度给网络的参数
• 更新网络权重，通常根据一个简单的更新法则：weight = weight - learning_rate * gradient。

网络定义

定义一个网络：

可以直接复制下面的代码创建*.py文件：

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)

结果：

用户只需要定义forward函数，而backward函数（计算梯度的部分）是通过autrograd自动定义的。可以在forward中应用任何张量操作。

模型中的可学习参数 通过net.parameters()返回：

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

终端结果：

下面试一个随机的32x32的输入。注意：这个网络（LeNet）的期望输入是32x32，如果要在MNIST数据集上应用这个网络，需要将数据集的图片resize到32x32。

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

终端结果：

使所有参数的梯度缓存置零，并用随机梯度反向传播：

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

注意，torch.nn只支持mini-batch。完整的torch.nn包仅支持mini-batch格式的输入样本，而不支持单个样本。比如，nn.Conv2d需要一个4D的张量为输入，尺寸是nSamples x nChannels x Height x Width。如果只有一个样本，需要用input.unsqueeze(0)来增加一个虚拟的batch维度。

在进一步处理之前，先重述一下目前看到的classes。

Recap：

• torch.Tensor——多维度array，支持backward()等autograd操作，内部也存储了相对于tensor的梯度。
• nn.Module——神经网络模型，方便封装参数、移至GPU、加载、输出等。
• nn.Parameter——张亮的一种，可以以一个模型的属性的形式自动注册为参数。
• autograd.Function——autograd操作前向和反向传播定义的实施、每个张量操作都创建了已至少一个Function节点，连接了创造函数的张量并编码其历史。

到目前为止我们已经了解了神经网络模型的定义、输入的处理和调用反向传播。下面来看一下损失的计算和网络权重的更新。

损失函数

损失函数接受（output, target）对作为输入，计算二者之间的距离。nn包内有几种不同的损失函数，一个比较简单的是n.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)

终端结果：

此时，如果跟踪反向传播方向的loss，用其.grad_fn属性，就能够看到类似下图这样的损失计算流程：

所以，在调用loss.backward时，整个图都对于损失被求导了，所有图内的张量（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

Backprop

对误差的反向传播只需要用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)

终端输出：

接下来看一下如何利用损失函数。

扩展阅读： 神经网络包包括了各种模块和损失函数，文件可以看这里。

下面来看最后一个内容，更新模型权重。

Update the weights

最简单的更新准则是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、Nesterove-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的。这是因为梯度会向Backprop部分所述进行积累。

代码总运行时间：3.092秒。

更多内容，欢迎加入星球讨论。