【Pytorch教程】Pytorch tutorials 03-Neural networks 中文翻译

Neural networks

本篇文章是本人对Pytorch官方教程的原创翻译(原文链接)仅供学习交流使用，转载请注明出处！

torch.nn包提供了各种神经网络的搭建方法。

nn依赖于autograd来对模型进行定义、求导。

nn.Module是所有模型的基类，它包含一个.forward(input)方法来产生output。

一个基本的卷积神经网络如上图所示，它用于对图像进行分类。

这是一个典型的前馈神经网络，它接受输入，并且将输入的数据一层接一层地传播给后面的神经网络，最后产生输出。

训练神经网络主要有一下几个基本步骤：

• 定义神经网络的结构和参数
• 将数据集迭代输入神经网络
• 处理输入的数据
• 计算损失（损失表示了输出值与正确值的差异）
• 反向传播（将损失传播给各个参数）
• 更新权重（常用算法weight= weight - learning_rate * gradient）

Define the network

接下来我们用pytorch仿照上图定义一个神经网络

import torch
import torch.nn as nn
import torch.nn.functional as F  # nn.functional提供了各种激励函数

class Net(nn.Module):
    
    def __init__(self):
        super(Net, self).__init__()
        # 第一个卷积层输入1张图片，输出6张图片，卷积核大小为5
        self.conv1 = nn.Conv2d(1, 6, 5)
        # 第二个卷积层输入6张图片，输出16张图片，卷积核大小为5
        self.conv2 = nn.Conv2d(6, 16, 5)
        
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    
    def forward(self, x):
        # 最大池化， 使用2x2的窗口，也就是在2x2的区域内选择1个最大特征
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # 如果窗口是正方形，也可以只指定一个参数
        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:]
        num_features = 1
        for s in size:
            num_features *= s
        
        return num_features

net = Net()
print(net) 

Net(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, 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)
)

可以注意到，torch.nn包含的这些常用的网络层对象都能直接调用，这是因为nn.Module实现了.__call__()方法，这使得对对象的调用将视为对.__call__()方法的调用。例如我们有一个可调用对象x，那么x()就等价于x.__call__()。对于nn.Module类, 它的.__call__()方法将会自动调用.forward()方法，例如self.conv1(x)等价于self.conv1.forward(x)

当我们实现了.forward()方法时，.backward()方法也就自动定义了，这得益于autograd机制。

.parameters()方法可以列出网络的参数。

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1的参数

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

我们用一个随机的32x32数据来测试网络是否能运行：

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

tensor([[ 0.0014,  0.0215, -0.0656, -0.1787,  0.0457,  0.0719,  0.0304,  0.0375,
         -0.0414, -0.0557]], grad_fn=)

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

torch.nn仅支持mini-batch的样本，不能只输入单个样本。
例如nn.Conv2d必须接受一个4维的Tensor，[样本数, 通道数, 长, 宽]
所以当我们只有单个样本时也要使用.unsqueeze(0)来增加样本维度

小结：

• nn.Module神经网络模块，搭建模型、封装参数都十分方便，同时也支持将参数迁移至GPU，导入导出等等。
• nn.Parameter一种特殊的Tensor，nn.Module会自动将传入的参数记为parameter。
• autograd.Function 为自动求导机制实现了前馈和反馈的定义，每个Tensor操作都至少包含一个Function，pytorch将这些function视为相互连接的结点，它们展示了新的tensor是如何产生的。

到这里，我们已经解决了以下步骤：

• 定义神经网络
• 输入数据
• 处理数据

为了训练神经网络，还需要解决：

• 误差计算
• 权重更新

Loss Function

损失函数负责计算预测值和真实值之间的差异，预测值即是神经网络的输出，真实值一般由数据集给定，也称为标签。

nn提供了很多常用的损失函数，最简单的是nn.MSELoss，即均方误差。

output = net(input)
target = torch.randn(10)  # 构造一组虚拟的标签
target = target.view(1, -1)  # 标签的尺寸必须和输出一致
criterion = nn.MSELoss()

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

tensor(0.9284, grad_fn=)

如果我们追踪loss产生的过程，调用它的.grad_fn属性，我们会看到这样一条路径：

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

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相关的Tensor都会计算梯度并且更新他们的.grad属性。

但在反向传播之前，我们必须清空网络的梯度，否则梯度会累加计算。

net.zero_grad()  #将所有的参数梯度清零

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.0016,  0.0073, -0.0150, -0.0061, -0.0189, -0.0052])

Update the weights

目前实际应用中最简单的权重更新方法叫做随机梯度下降法(Stochastic Gradient Descent, SGD):weight = weight - learning_rate * gradient

我们可以用Python简单实现一个SGD算法：

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

然而在训练神经网络的时候，常常用到不同的权重更新方法，为此pytorch提供了一个optim模块：

import torch.optim as optim

# 创建优化器
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 将此段代码放入每次迭代训练中
optimizer.zero_grad()  # 清空梯度缓存
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()  # 更新一次