未经允许，不得转载，谢谢~~

我们现在已经对autograd包有了一个基本的认识,现在来学习一下实现神经网络的包torch.nn.

• torch.nn是用来构建神经网络的.
• nn包内部通过调用autograd包来实现神经网络模块的定义及梯度的计算等等.
• nn.Module类包含了神经网络各层的定义,以及forward(input)前向传播函数的定义,返回输出值output.

Neural Networks

以下是一个对数字图像进行分类的网络结构图:

网络的结构在图中可以明显的看出来了,接受输入图片,依次经过不同的网络层,最后得到输出.

对于神经网络的典型处理如下所示:

1. 定义待可学习参数的网络结构;
2. 数据集输入;
3. 对输入进行处理,主要体现在网络的前向传播;
4. 计算loss function;
5. 反向传播求梯度;
6. 根据梯度改变参数值,最简单的实现方式为:
   weight = weight - learning_rate * gradient

Define the network

用pytorch来实现上述网络结构的定义.

import torch
from torch.autograd import Variable
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 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)

最后的输出结果为:

learn more about the network

• 在pytorch中只需要定义forward函数即可, 反向传播backward的部分在你使用autograd时会自动生成.
• 在forward函数中可以对Tensor进行任何操作.
• 一个模块可学习的参数都在net.parameters中

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

以上代码段实现将该神经网络的可学习参数都放到params中,并且输出了第一层conv的参数大小.

结果如下:

可以看到conv1的参数大小为(6,1,5,5)与网络结构相符合.

• forward函数的输入与输出都是autograd.Variable类型的.

• 该网络的期望输入大小是32*32.
  以随机的32*32变量作为输入:

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

• 得到输出结果如下所示:

  
  
  

  可以得到了10个评分值.

• 将梯度清0,并以初始随机的梯度进行反向传播:

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

note

• torch.nn包仅支持对批量数据的处理,而不能对单个样本进行处理.
• 例如,nn.Conv2d只接受4维的张量:
  nSamples * nChannels * Height * Width
• 如果只有单个样本,那么使用input.unsqueeze(0)来增加假的batch维度.

loss function

• 将(output,target)作为输入
• 计算output与target两者之间的差距
• nn包下提供了几种不同的损失函数．
• 最简单的是nn.MSELoss,计算两者之间的平均方差值

如下所示：

output = net(input)
target = Variable(torch.arange(1, 11))  # a dummy target, for example
criterion = nn.MSELoss()

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

输出结果如下所示：

沿着loss的反向传播方向，依次用.grad_fn属性，就可以得到如下所示的计算图．

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

所以当我们调用loss.backward()函数的时候，整张图都被一次计算误差，所有Variable的.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.backgrad()函数即可．
• 但是由于变量的梯度是累加的，所以在求backward之前应该先对现有的梯度清零．
  以下调用了loss.backgrad()函数，并分别查看conv1.bais在此之前和之后的值．

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

• 通过执行以下这段简单的代码即可实现SGD:

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

• 为了满足不同的更新规则，比如 SGD, Nesterov-SGD, Adam, RMSProp等pttorch提供了一个很小的包：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

more

更多关于torch.nn模块及损失函数的信息戳这里哦～

回顾梳理

之前博客内容

• torch.Tensor
  可以支持GPU计算的多维数组.
• autograd.Variable
  １．封装了Tensor
  ２．并且实现了跟Tensor计算一样的API接口．
  ３．并且增加了backward()函数求梯度．
• nn.Module
  １．神经网络模块
  ２．可以方便的将参数在CPU与GPU之间切换．
• nn.Parameter
  作为Module的属性，在运行过程中自动产生的，用来放网络中待学习的参数．
• autograd.Function
  １．实现了自动求梯度功能的前向和反向定义．
  ２．每个跟Varaible有关的操作都至少创造了一个Function的对象．

本次博客内容

• 怎么样定义一个神经网络
• 处理输入以及调用backward函数
• 计算损失函数
• 迭代更新网络的权重