《 60分钟快速入门学习pytorch笔记三》神经网络

神经网络可以使用工具包torch.nn进行创建。
前面介绍了 autograd包， torch.nn 依赖于 autograd 用于定义和求导模型。 nn.Module 包括layers（神经网络层）, 以及前向传播函数 forward(input)，其返回结果 output.
例如我们来看一下手写字体识别的案例。

这是一个简单的前馈神经网络。接受输入，向前传几层，然后输出结果。
一个神经网络训练的简单过程是：

• 定义一个具有可学习参数的神经网络。
• 输入数据集迭代
• 网络运算数据输入的计算结果
• 计算损失 (how far is the output from being correct)
• 传播梯度
• 跟新权值，通常可以简单的使用梯度下降: weight = weight - learning_rate * 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, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1,6,5)
        self.conv2 = nn.Conv2d(6,16,5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
    def foward(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 backward(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=(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)
)

你只需定义forward函数,backward函数(计算梯度)在使用autograd时自动为你创建.你可以在forward函数中使用Tensor的任何操作.

网络的学习到的参数可以通过net.parameters()获取。

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

输出

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

让我们随机输入一个 32x32 的数据。
注意:这个网络(LeNet)期望的输入大小是3232.如果使用MNIST数据集来训练这个网络,请把图片大小重新调整到3232.

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

输出

tensor([[ 0.0951, -0.0383,  0.0542,  0.1016,  0.1078,  0.0605,  0.0324,  0.0815,
         -0.0856,  0.0489]], grad_fn=<ThAddmmBackward>)

使所有参数的梯度恢复为0，然后使用随机梯度后向传播:

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

注意：
torch.nn 只支持mini-batches. 整个 torch.nn 包只接受批样本，不接受单个样本。

例如, nn.Conv2d 接受一个4D的张量形如： nSamples x nChannels x Height x Width.

如果你只有一个样本，那就使用 input.unsqueeze(0) 创造一个假的mini-batch。

在进一步之前，我们来回顾目前你所见到的所有类。

回顾：

• torch.Tensor - 一个多维度的数组，支持自动梯度 backward()。其梯度任然保存在张量里。
• nn.Module - 神经网络模型。方便的封装参数，可以导出模型到GPU，加载模型，导出模型等。
• nn.Parameter - 一种张量, 自动注册为paramter当赋给 Module作为属性。
• autograd.Function-实现一个自动求导操作的前向和反向定义,每个变量操作至少创建一个函数节点,(Every Variable operation, creates at least a single Function node, that connects to functions that created a Variable and encodes its history.)

到此, 我们覆盖了:

• 定义一个网络
• 处理输入和反向传播。

剩余的内容:

• 计算损失
• 更新网络的参数

损失函数

一个损失函数接受（output,targe)对作为输入，计算output和target相差的程度。
nn包里有多种不同的 loss functions 。最简单的损失函数是: nn.MSELoss ，计算(output,target)间的均方误差损失函数。
例如：

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.3638, grad_fn=<MseLossBackward>)

现在,你反向跟踪loss,使用它的.grad_fn属性,你会看到向下面这样的一个计算图:

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

所以, 当你调用loss.backward(),整个图关于损失被求导,图中所有变量将拥有.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 0x7f82bad9ce80>
<AddmmBackward object at 0x7f82bad9ee80>
<AccumulateGrad object at 0x7f82bad9ce80>

反向传播

为了反向传播误差，我们必须使用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.0181, -0.0048, -0.0229, -0.0138, -0.0088, -0.0107])

现在我们已知道如何使用损失函数.

稍后阅读

神经网络包包含了各种用来构成深度神经网络构建块的模块和损失函数,一份完整的文档查看这里

唯一剩下的内容:

• 更新网络的权重

更新权重

实践中最简单的更新规则是随机梯度下降(SGD)
$$weight=weight-learningRate\ast 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.前面在Backprop说了，梯度会累加起来的。