Pytorch教程入门系列5----神经网络核心torch.nn工具箱介绍

系列文章目录

---

---

前言

经过前面pytorch基本小API的学习，我们了解了pytorch的一些枝叶。接下来我们来重点学习pytorch里面最能快速上手的API----torch.nn，本文开始介绍神经网络的核心torch.nn的基础内容。

---

一、troch.nn的定位

torch.nn 是pytorch 的一种API工具，该工具是为了快速搭建神经网络任务而创建的。

二、torch.nn几大模块

1.nn.Module

神经网络模块的基类，想要实现神经网络模型只需要继承这个基类，主要使用init()方法和forward()方法。

__init()__方法

重载init ()初始化。即在init()进行参数和模型结构的构建。类定义了所需要的arguments和模块的parameters 。

forward()方法

forward()前向传播，在forward进行子模块的拼接，在forward函数中将arguments和parameters传给nn.functional的对应的函数来实现forward功能
心里有模型，再拿它来实现！它是实现模型不是创造模型。
举例：以全连接的结构利用init()来构建模型

	#  import的内容不赘述
    # 首先建立一个子模块，类取名Linear，继承nn.Module
    class Linear(nn.Module): 
    	# 定义__init__()方法，初始化Linear 
      def __init__(self, in_dim, out_dim):  
          super(Linear, self).__init__()   # 调用nn.Module的构造函数,进行重载
          self.w = nn.Parameter(torch.randn(in_dim, out_dim)) # 使用nn.Parameter来构造需要学习的参数
          self.b = nn.Parameter(torch.randn(out_dim))
      # 定义forward()方法,在forward中实现前向传播过程
      def forward(self, x):
          x = x.matmul(self.w)# 使用Tensor.matmul实现矩阵相乘           
          y = x + self.b.expand_as(x)  # 使用Tensor.expand_as()来保证矩阵形状一致    
          return y # class Linear需要输入输出
          
          
    # 再来定义一个模块，继承nn.Module，并调用了Linear的子module实现嵌套，模型复杂化
    class Perception(nn.Module):
    #建模块
      def __init__(self, in_dim, hid_dim, out_dim):
          super(Perception, self).__init__()
          self.layer1 =  Linear(in_dim, hid_dim)
          self.layer2  = Linear(hid_dim, out_dim)
      #拼接子模块
      def forward(self, x):
          x = self.layer1(x)
          y = torch.sigmoid(x)    # 使用torch中的sigmoid作为激活函数
          y = self.layer2(y)
          y = torch.sigmoid(y)
          return y

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

nn.Parameter()方法

使用nn.Parameter来构造需要学习的参数，默认需要求导

 self.w = nn.Parameter(torch.randn(in_dim, out_dim)) 
1

2.nn.functional库

与nn.Module类似，什么时候使用nn.Module，什么时候使用nn.functional呢？
一般情况下，如果模型有可学习的参数，最好用nn.Module，其他情况nn.functional相对更简单一些例如：激活层和BN层，损失函数等

以损失函数举例。

    >>> from torch import nn
    >>> import torch.nn.functional as F
    
    cost = torch.nn.MSELoss(reduction='mean')
    # 实例化nn中的交叉熵损失类
    >>> criterion = nn.CrossEntropyLoss()
    # 调用交叉熵损失
    >>> loss_nn = criterion(output, label)
    # 由于F.cross_entropy是一个函数，因此可以直接调用，不需要实例化，两者求得的损失值相同
    >>> loss_functional = F.cross_entropy(output, label)
1
2
3
4
5
6
7
8
9
10

3.nn.Sequential()方法

nn.Sequential()模块来快速搭建模型，而不必在forward()函数中一层一层地手动前向传播。更适用于多层卷积等情况使用nn.Sequential()模块。

    my_nn = torch.nn.Sequential(
    torch.nn.Linear(input_size, hidden_size),
    torch.nn.Sigmoid(),
    torch.nn.Linear(hidden_size, output_size),
)
1
2
3
4
5

4.nn.optim方法

包含了各种常见的优化算法：
包括随机梯度下降算法SGD（Stochastic Gradient Descent，随机梯度下降）、Adam（Adaptive Moment Estimation）、Adagrad、RMSProp等优化算法。
清空梯度不在累加：图也被销毁
梯度更新：

    >>> import torch
    >>> from torch import optim
    >>> from torch import nn
    # 采用SGD优化器，学习率为0.01
    >>> optimizer = optim.SGD(params = model.parameters(), lr=0.01)
    # 或者采用Adam优化器，学习率为0.001
    >>>optimizer = optim.Adam(net.parameters(), lr=0.001)
    >>> data = torch.randn(10, 28＊28)
    >>> output = model(data)
    # 求损失，在PyTorch中，损失函数可以看做是网络的某一层而放到模型定义中，实际使用时更偏向于作为功能函数而放到前向传播过程中
    >>> criterion = nn.CrossEntropyLoss()
    >>> loss = criterion(output, label)
    # 清空梯度，在每次优化前都需要进行此操作
    >>> optimizer.zero_grad()
    # 损失的反向传播
    >>> loss.backward()
    # 利用优化器进行梯度更新
    >>> optimizer.step()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

总结

以上就是今天要讲的内容，本文将torch.nn工具箱中常用的函数和方法，做了一些介绍，为识别深度学习网络的个层，混个脸熟。后续将开始介绍更加贴近编写神经网络的一般操作，理顺神经网络流程，方便我们自己动手写出神经网络。