参考来源：
CSDN：pytorch教程之 nn.Sequential 类详解——使用 Sequential 类来自定义顺序连接模型

前言：类似于 keras 中的序贯模型，当一个模型较简单的时候，我们可以使用 **torch.nn.Sequential** 类来实现简单的顺序连接模型。这个模型也是继承自 Module 类的，关于这个类，后面的文章会详细介绍。

1. 关于 Sequential 类的简介

先来看一下它的定义吧，在之前，我们首先需要明确一个特别重要的观念，那就是—— **torch** 的核心是Module类，
Module 类在下面这个模块中：
D:\ProgramData\Anaconda3\envs\pytorch1.1.0\Lib\site-packages\torch\nn\modules\module.py
Sequential 继承自 Module，在下面这个模块里面：
D:\ProgramData\Anaconda3\envs\pytorch1.1.0\Lib\site-packages\torch\nn\modules\container.py
这样看起来，Sequential 似乎是一个容器，的确，他确确实实是可以作为一个容器包装机各层，我在下一篇文章会说到，这里还是先简单看一下它的定义：

  1. class Sequential(Module): # 继承Module
  2.     def __init__(self, *args):  # 重写了构造函数
  3.     def _get_item_by_idx(self, iterator, idx):
  4.     def __getitem__(self, idx):
  5.     def __setitem__(self, idx, module):
  6.     def __delitem__(self, idx):
  7.     def __len__(self):
  8.     def __dir__(self):
  9.     def forward(self, input):  # 重写关键方法forward

这里还看一下这个所谓的 container.py 里面还有那些“容器”存在：

2. Sequential类的 3 种实现

2.1 最简单的序贯模型

  1. import torch.nn as nn
  2. model = nn.Sequential(
  3.                   nn.Conv2d(1,20,5),
  4.                   nn.ReLU(),
  5.                   nn.Conv2d(20,64,5),
  6.                   nn.ReLU()
  7.                 )
  9. print(model)
  10. print(model[2]) # 通过索引获取第几个层
  13. '''
  14. 运行结果为：
  15. Sequential(
  16.   (0): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  17.   (1): ReLU()
  18.   (2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  19.   (3): ReLU()
  20. )
  21. Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  22. '''

注意：这样做有一个问题，每一个层是没有名称，默认的是以 0、1、2、3 来命名，从上面的运行结果也可以看出。

2.2 给每一个层添加名称

  1. import torch.nn as nn
  2. from collections import OrderedDict
  3. model = nn.Sequential(OrderedDict([
  4.                   ('conv1', nn.Conv2d(1,20,5)),
  5.                   ('relu1', nn.ReLU()),
  6.                   ('conv2', nn.Conv2d(20,64,5)),
  7.                   ('relu2', nn.ReLU())
  8.                 ]))
  10. print(model)
  11. print(model[2]) # 通过索引获取第几个层
  14. '''
  15. 运行结果为：
  16. Sequential(
  17.   (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  18.   (relu1): ReLU()
  19.   (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  20.   (relu2): ReLU()
  21. )
  22. Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  23. '''

注意：从上面的结果中可以看出，这个时候每一个层都有了自己的名称，但是此时需要注意，我并不能够通过名称直接获取层，依然只能通过索引 index，即

  • **model[2]** 是正确的。
  • **model["conv2"]** 是错误的。

这其实是由它的定义实现的，看上面的 Sequenrial 定义可知，只支持 index 访问。

2.3 Sequential 的第三种实现

  1. import torch.nn as nn
  2. from collections import OrderedDict
  3. model = nn.Sequential()
  4. model.add_module("conv1",nn.Conv2d(1,20,5))
  5. model.add_module('relu1', nn.ReLU())
  6. model.add_module('conv2', nn.Conv2d(20,64,5))
  7. model.add_module('relu2', nn.ReLU())
  9. print(model)
  10. print(model[2]) # 通过索引获取第几个层
  13. '''
  14. 运行结果为：
  15. Sequential(
  16.   (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  17.   (relu1): ReLU()
  18.   (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  19.   (relu2): ReLU()
  20. )
  21. Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  22. '''

熟悉 keras 的小伙伴在这里一定特别熟悉，这不就是 keras 的做法嘛，的确是的，但是 Sequential 里面好像并没有定义。
add_module() 方法啊，实际上，这个方法是定义在它的父类 Module 里面的，Sequential 继承了而已，它的定义如下：

  1. def add_module(self, name, module):

总结：上面的 3 种定义顺序模型的方法是较为常见的，但是我们说了 Sequential 除了本身可以用来定义模型之外，它还可以包装层，把几个层包装起来像一个块一样，这在后面会说到。