nn.Module的基本使用

1. 什么是nn.Module

• nn.Module模块式神经网络模型的基类，它提供了一些很简单方便的结构，来构建一个神经网络

• 在pytorch的官方文档(https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module)中提供了一个基于 nn.Module 的简单样例，这也将是一个基本的前向传播结构

  import torch.nn as nn
  import torch.nn.functional as F
  
  class Model(nn.Module):
      def __init__(self):
          super().__init__()
          self.conv1 = nn.Conv2d(1, 20, 5)
          self.conv2 = nn.Conv2d(20, 20, 5)
  
      def forward(self, x):
          x = F.relu(self.conv1(x))
          return F.relu(self.conv2(x))
  

  • 类 Model 继承了 nn.Module 类
  • init函数中，使用 nn.Conv2d() 创建了两个卷积结构，用于后续的数据处理
  • 对于输入数据 x 的前向传播进行了如下操作：
    • F.relu(self.conv1(x)): 进行卷积 conv1 操作后进行非线性变换
    • F.relu(self.conv2(x)): 再进行卷积 conv2 操作后进新非线性变换为返回值

2. 使用 nn.Module 创建前向传播结构

• 首先需要导入 nn 模块

  from torch import nn
  

• 创建类 Model ， 继承 nn.Module 构建一个前向传播结构

  class Model(nn.Module):
      def __init__(self):
          super(Model, self).__init__()
          self.conv = nn.Conv2d(1, 20, 5)
          
      def forward(self, x):
          x1 = x + 1 # layer1
          x2 = x1 + 1 # layer2
          x3 = x2 + 1 # layer3
          return x3 # output
  

  • 首先在 init函数中需要 super表示继承父类，也可以在这里定义很多结构，如卷积层结构、池化层结构，全连接层结构等等
  • 重写forward函数：这个函数是前向传播结构的主体，上述代码中，模拟了输入数据 X 前向传播过程中，通过三层网络结构实例

• 使用创建的 Model 类来处理数据

  import torch
  x = torch.tensor([1, 2, 3])
  model = Model()
  y = model(x) 
  # y = tensor([4, 5, 6])
  

  • 创建了一个输入数据 x 以及 Model 类的实例， model
  • model(X):会将x直接进行 forward()操作，并将最后的计算结果返回(forward()中的 return的内容)

3. nn模块中包含的用于创建神经网络的层和结构

• 卷积层

  nn.Conv1d()
  nn.Conv2d()
  nn.Conv3d()
  

• 最大池化层

  nn.MaxPool1d()
  nn.MaxPool2d()
  nn.MaxPool3d()
  

• 循环层

  nn.RNN() # 基本循环神经网络
  nn.LSTM() # 长短期记忆网络
  nn.GRU() # 门控循环单元层
  

• 规范化层

  nn.BatchNorm1d() # 一维批归一化层
  nn.BatchNorm2d()
  nn.BatchNorm3d()
  nn.LayerNorm() # 层归一化层
  

• 激活函数

  nn.ReLU() # 修正线性单元
  nn.Sigmoid() # Sigmoid激活函数
  nn.Tanh() # 双曲正切激活
  nn.LeakyReLU() # 带泄露的ReLU
  nn.Softmax() #Softmax函数
  

• 正则化层

  nn.Dropout() # Dropout层
  nn.Dropout1d()
  nn.Dropout2d()
  nn.Dropout3d()
  

• 嵌入层

  nn.Embedding()
  

• 自注意力

  nn.MultiheadAttention() # 多头注意力机制
  

• 如果 nn 模块中没有符合要求的层结构，可以自定义层结构后应用在层模型中。比如我们想定义一个层结构，实现输入数据减一的操作(这只是一个简单例子，实际上不需要专门重新定义一个层结构)

  • 自定义层结构，实现: 输入数据减一

    class diy(nn.Module):
        def __init__(self):
            super().__init_()
            
        def forward(self, x):
            x = x -1 
            return x
    

    自定义层结构的类名为 diy: 前向传播中实现对输入数据减一的操作

  • 使用自定义的层结构

    class Model(nn.Module):
        def __init__(self):
            super().__init__()
            self.DIY = diy() # 创建自定义层结构的实例
        def forward(self, x):
            x = self.DIY(x)
            return x
    

  • 进行样例数据展示

    x = torch.tensor([1, 2, 3])
    y = Model()(x) # y = tensor([0, 1, 2])