快速入门PyTorch(2)--如何构建一个神经网络

原文连接：mp.weixin.qq.com/s/Q8tNXsDh6…

快速入门 PyTorch 教程第二篇，这篇介绍如何构建一个神经网络。上一篇文章：

• 快速入门Pytorch(1)--安装、张量以及梯度

本文的目录：

---

3. 神经网络

在 PyTorch 中 torch.nn 专门用于实现神经网络。其中 nn.Module 包含了网络层的搭建，以及一个方法-- forward(input) ，并返回网络的输出 outptu .

下面是一个经典的 LeNet 网络，用于对字符进行分类。

对于神经网络来讲，一个标准的训练流程是这样的：

• 定义一个多层的神经网络
• 对数据集的预处理并准备做为网络的输入
• 将数据输入到网络
• 计算网络的损失
• 反向传播，计算梯度
• 更新网络的梯度，一个简单的更新规则是 weight = weight - learning_rate * gradient

3.1 定义网络

首先定义一个神经网络，下面是一个 5 层的卷积神经网络，包含两层卷积层和三层全链接层：

import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    
    def __init__(self):
        super(Net, self).__init__()
        # 输入图像是单通道，conv1 kenrnel size=5*5，输出通道 6
        self.conv1 = nn.Conv2d(1, 6, 5)
        # conv2 kernel size=5*5, 输出通道 16
        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):
        # max-pooling 采用一个 (2,2) 的滑动窗口
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # 核(kernel)大小是方形的话，可仅定义一个数字，如 (2,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):
        # 除了 batch 维度外的全部维度
        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)
)
复制代码

这里必须实现 forward 函数，而 backward 函数在采用 autograd 时就自动定义好了，在 forward 方法能够采用任何的张量操做。

net.parameters() 能够返回网络的训练参数，使用例子以下：

params = list(net.parameters())
print('参数数量: ', len(params))
# conv1.weight
print('第一个参数大小: ', params[0].size())
复制代码

输出：

参数数量:  10
第一个参数大小:  torch.Size([6, 1, 5, 5])
复制代码

而后简单测试下这个网络，随机生成一个 32*32 的输入：

# 随机定义一个变量输入网络
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
复制代码

输出结果：

tensor([[ 0.1005,  0.0263,  0.0013, -0.1157, -0.1197, -0.0141,  0.1425, -0.0521,
          0.0689,  0.0220]], grad_fn=<ThAddmmBackward>)
复制代码

接着反向传播须要先清空梯度缓存，并反向传播随机梯度：

# 清空全部参数的梯度缓存，而后计算随机梯度进行反向传播
net.zero_grad()
out.backward(torch.randn(1, 10))
复制代码

注意：

torch.nn 只支持**小批量(mini-batches)**数据，也就是输入不能是单个样本，好比对于 nn.Conv2d 接收的输入是一个 4 维张量--nSamples * nChannels * Height * Width 。

因此，若是你输入的是单个样本，须要采用 input.unsqueeze(0) 来扩充一个假的 batch 维度，即从 3 维变为 4 维。

3.2 损失函数

损失函数的输入是 (output, target) ，即网络输出和真实标签对的数据，而后返回一个数值表示网络输出和真实标签的差距。

PyTorch 中其实已经定义了很多的损失函数，这里仅采用简单的均方偏差：nn.MSELoss ，例子以下：

output = net(input)
# 定义伪标签
target = torch.randn(10)
# 调整大小，使得和 output 同样的 size
target = target.view(1, -1)
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)
复制代码

输出以下：

tensor(0.6524, grad_fn=<MseLossBackward>)
复制代码

这里，整个网络的数据输入到输出经历的计算图以下所示，其实也就是数据从输入层到输出层，计算 loss 的过程。

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss
复制代码

若是调用 loss.backward() ，那么整个图都是可微分的，也就是说包括 loss ，图中的全部张量变量，只要其属性 requires_grad=True ，那么其梯度 .grad 张量都会随着梯度一直累计。

用代码来讲明：

# MSELoss
print(loss.grad_fn)
# Linear layer
print(loss.grad_fn.next_functions[0][0])
# Relu
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])
复制代码

输出：

<MseLossBackward object at 0x0000019C0C349908>

<ThAddmmBackward object at 0x0000019C0C365A58>

<ExpandBackward object at 0x0000019C0C3659E8>
复制代码

3.3 反向传播

反向传播的实现只须要调用 loss.backward() 便可，固然首先须要清空当前梯度缓存，即.zero_grad() 方法，不然以前的梯度会累加到当前的梯度，这样会影响权值参数的更新。

下面是一个简单的例子，以 conv1 层的偏置参数 bias 在反向传播先后的结果为例：

# 清空全部参数的梯度缓存
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.0069,  0.0021,  0.0090, -0.0060, -0.0008, -0.0073])
复制代码

了解更多有关 torch.nn 库，能够查看官方文档：

pytorch.org/docs/stable…

3.4 更新权重

采用随机梯度降低(Stochastic Gradient Descent, SGD)方法的最简单的更新权重规则以下：

weight = weight - learning_rate * gradient

按照这个规则，代码实现以下所示：

# 简单实现权重的更新例子
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
# 建立优化器
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 在训练过程当中执行下列操做
optimizer.zero_grad() # 清空梯度缓存
output = net(input)
loss = criterion(output, target)
loss.backward()
# 更新权重
optimizer.step()
复制代码

注意，一样须要调用 optimizer.zero_grad() 方法清空梯度缓存。

本小节教程：

pytorch.org/tutorials/b…

本小节的代码：

github.com/ccc013/Deep…

---

小结

第二篇主要介绍了搭建一个神经网络，包括定义网络、选择损失函数、反向传播计算梯度和更新权值参数。

欢迎关注个人微信公众号--机器学习与计算机视觉，或者扫描下方的二维码，你们一块儿交流，学习和进步！

往期精彩推荐

机器学习系列

• 初学者的机器学习入门实战教程！
• 模型评估、过拟合欠拟合以及超参数调优方法
• 经常使用机器学习算法汇总比较(完）
• 经常使用机器学习算法汇总比较(上）
• 机器学习入门系列(2)--如何构建一个完整的机器学习项目(一)
• 特征工程之数据预处理（上）
• 来了解下计算机视觉的八大应用

Github项目 & 资源教程推荐

• [Github 项目推荐] 一个更好阅读和查找论文的网站
• [资源分享] TensorFlow 官方中文版教程来了
• 必读的AI和深度学习博客
• [教程]一份简单易懂的 TensorFlow 教程
• [资源]推荐一些Python书籍和教程，入门和进阶的都有！
• [Github项目推荐] 机器学习& Python 知识点速查表
• [Github项目推荐] 推荐三个助你更好利用Github的工具
• Github上的各大高校资料以及国外公开课视频
• 这些单词你都念对了吗？顺便推荐三份程序员专属英语教程！