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=<AddmmBackward>)
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=<MseLossBackward>)
如果我们追踪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
<MseLossBackward object at 0x000001A0F053E5C8>
<AddmmBackward object at 0x000001A0F053E688>
<AccumulateGrad object at 0x000001A0F053E5C8>
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() # 更新一次
