PyTorch 学习 （3） 神经网络

PyTorch 学习 （3） 神经网络

来自 PyTorch 教程 Deep Learning with PyTorch: A 60 Minute Blitz > NEURAL NETWORKS

在 PyTorch 中我们使用 torch.nn 来构建神经网络

nn 通过 autograd 去定义模型，一个模型 nn.Module 包含很多层，还有一个方法 forward 用来返回输出

如图所示，表示了一个用来对图像进行分类的网络

这是一个简单的前馈网络

对于一个神经网络，通常使用如下的步骤进行训练：

• 定义一个拥有一些学习参数或者权重的神经网络
• 遍历输入数据集
• 将数据输入网络
• 计算损失 loss
• 将误差传递回网络改变学习参数
• 使用更新规则更新网络参数 （通常使用学习率）

定义一个网络

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 输入图像, 6 输出通道, 3x3 平方卷积核
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        #  (2, 2) 最大池化
        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:]  # 除了 batch_size
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()

我们只需要定义正向函数 forward，autograd 就会自动生成反馈函数，可以在 forward 中使用所有张量操作

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

for p in list(net.parameters()):
    print(p.size())

本网络的期望输入是 32x32

_input = torch.randn(1, 1, 32, 32)
out = net(_input)

将梯度缓冲清零，然后使用随机梯度反馈

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

torch.nn 只支持 mini-batches ，输入不支持单个样本，需要打包成 mini-batch

对于 nn.Con2d 需要采用四维张量 nSamples x nChannels x Height x Width

对于单个样本，可以使用 .unsqueeze(0) 增加额外的维度

回顾

torch.Tensor - 一个多维数组，提供了诸如 backward 这类 autograd 操作

nn.Module - 神经网络模块，完成对各种参数的封装，并且可以完成导入、加载、移动到 GPU 等操作

nn.Parameter - 一种张量，在 nn.Module 中被自动生成

autograd.Function - 实现 autograd 操作的正反向定义，每一次有关张量的操作都会创建至少一个 Function 来引用创建这个张量的方法，并将历史过程编码

现在我们已经完成了对神经网络的定义，并且可以处理输入，向后调用

接下来我们来计算损失 loss function ，更新权重

损失函数 Loss Function

损失函数的输入是 (output, target)， 计算得到一个值用来表示输出与目标之间的差距

torch.nn 中有多种损失函数，一个简单的例子是 nn.MSELoss ，这个损失函数用来计算输出与目标的均方误差

out = net(input)
target = torch.randn(1, 10)
criterion = nn.MSELoss()
loss = criterion(out, target)

现在，如果对 loss 进行向后追踪，通过 grad_fn 属性，可以得到一张如下的所示的图

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

这时我们调用 loss.backward() 就会对所有 requires_grad=True 的张量就会计算相关的梯度

我们可以通过如下操作查看

loss.grad_fn
loss.grad_fn.next_functions[0][0]

反向传播 Backprop

通过调用 loss.backward() 我们就可以向后传递误差。在这之前我们需要先清除现有梯度，否则会发生累加

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

现在我们知道了如何调用损失函数，最后，我们需要更新网络的权重

更新权重

最简单的更新规则就是随机梯度下降 SGD

weight = weight - learning_rate * gradient

可以使用简单的 python 代码实现

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

在 pytorch 中，torch.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()  # 更新权重