【nn.Sequential()】菜鸟实用教程指南

本文旨在探讨在深度学习过程中对 nn.Sequential()方法的应用。在早期的代码学习中，我们很少看到使用 nn.Sequential()来定义网络层，但随着学习的深入，这种方法逐渐流行并被广泛采用。为了帮助大家更好地理解和使用这一工具，本章节将详细讲解 nn.Sequential()的使用方法及其与传统定义网络层方式的区别。

首先，我们将阐明两种方法之间的差异，确保大家理解nn.Sequential()的实用性。随后，我们会详解PyTorch官方文档中关于nn.Sequential()的部分，目的是让大家能够轻松并深入地理解这一方法。

nn.Sequential()不仅为神经网络的构建带来便利，还大幅简化了代码的复杂度。通过本文的详细讲解和示例，希望大家能够无障碍地掌握并应用nn.Sequential()，从而在神经网络的学习和研究中取得更好的成效。

简化您的模型定义过程的同时，我们推荐查阅PyTorch官方文档以联合理解和加深对nn.Sequential()的认识，您可以通过以下链接访问：PyTorch nn.Sequential Documentation。结合本博客与官方文档的阅读，可以极大提升您的学习效率。

1.使用nn.Sequential()的优势

在PyTorch中，nn.Sequential()是一个非常便利的模块，用于快速、清晰地组织多个子模块（如层或操作）成一个整体的网络。这种格式展现以下优点：

1. 代码简洁：通过nn.Sequential()实现的代码更为简洁，易于书写和维护。
2. 模型模块化：允许将复杂的模型分解为简单的、重复使用的模块。
3. 减少错误：由于结构的标准化，使用此方法可以减少编码错误。

2.实例对比

不使用nn.Sequential()，直接继承nn.Module可能需要更多的设置，如下所示：

class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        self.layer1 = nn.Linear(784, 256)
        self.layer2 = nn.Linear(256, 128)
        self.layer3 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x

==需要首先初始化了各种不同的网络层。==具体操作包括实例化三个线性层；分别是从 784 到 256 维，从 256 到 128 维，以及从 128 到 10 维的全连接层。==在前向传播方法 forward 中，数据按顺序通过这些定义好的网络层。==在前两个网络层后应用了 ReLU 激活函数，以引入非线性因素，增强模型的表达能力。最后一层的输出直接作为模型的最终输出，该输出通常用于分类任务的后续处理。

在使用nn.Sequential()后，模型更为简洁：

class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        self.layers = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

    def forward(self, x):
        return self.layers(x)

这种方式不仅简化了代码，还使网络结构一目了然，降低了从设计到实现的复杂性。

3.官网文档

官方文档给出了PyTorch中这一方法的详尽解释，torch.nn.Sequential 是一个特殊的模块容器，用于按顺序组织模块（如层或函数）并自动执行它们的前向传递。

torch.nn.Sequential 功能详解

• 自动前向传播：当你给 Sequential 容器添加模块时，PyTorch 会自动管理这些模块的前向传播过程。即输入数据首先传递给第一个模块，该模块的输出再传递给下一个模块，依此类推，直到最后一个模块，最终输出结果。**

如何理解自动前向传播？
就是你使用Sequential就类似于构建了一个完成的网络框架，前向传播啥的都写好。具体来个例子

下面举个例子理解下这个封装：
主要的优势就是整合小型网络（例如简单的CNN）到更大的模型中Sequential存在着绝对的优势

1. 未使用 nn.Sequential 整合到大型模型
   在这种情况下，需要手动定义每一层及其在 forward 方法中的连接逻辑。

超简单的CNN定义 (未使用 nn.Sequential)

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.relu1 = nn.ReLU()
        self.conv2 = nn.Conv2d(20, 64, 5)
        self.relu2 = nn.ReLU()

    def forward(self, x):
        x = self.relu1(self.conv1(x))
        x = self.relu2(self.conv2(x))
        return x

在大型模型中使用 SimpleCNN

class BiggerModel(nn.Module):
    def __init__(self):
        super(BiggerModel, self).__init__()
        self.simple_cnn = SimpleCNN()
        self.fc = nn.Linear(64, 10)

    def forward(self, x):
        x = self.simple_cnn(x)  # 使用已定义的CNN模块
        x = x.view(x.size(0), -1)  # 展平操作，为全连接层准备
        x = self.fc(x)  # 全连接层进行分类
        return x

2. 使用 nn.Sequential 直接在大型网络中应用
使用 nn.Sequential 可以简化模型的定义和整合过程，使得整个网络结构更加清晰且易于管理。不需要之前反复的定义网络主体和前向传播的过程。

在大型模型中应用 simple_cnn

class BiggerModel(nn.Module):
    def __init__(self):
        super(BiggerModel, self).__init__()
        self.simple_cnn = nn.Sequential(
					    nn.Conv2d(1, 20, 5),
					    nn.ReLU(),
					    nn.Conv2d(20, 64, 5),
					    nn.ReLU()
					)  # 直接使用预定义的Sequential模型
        self.fc = nn.Linear(64, 10)

    def forward(self, x):
        x = self.simple_cnn(x)  # 使用Sequential定义的CNN
        x = x.view(x.size(0), -1)  # Flatten操作，为全连接层准备
        x = self.fc(x)  # 全连接层处理
        return x

因此，使用 nn.Sequential 可以视为对标准神经网络设计流程的一个高级封装，它允许开发者更专注于网络结构的设计，而不是细节的实现。这对于快速开发和原型制作而言尤为有价值。

下面是其他的两个优势

• 模块有序管理：在 Sequential 中添加的模块会按照它们被添加的顺序进行管理。这种方式具有很高的透明度，使得模型的数据流动易于追踪和理解。
• 容器处理：Sequential 容器本身可以像单个模块那样被处理。若对 Sequential 进行变换（如设备变更、参数重置），这些变换会应用至它存储的所有子模块。

官方文档中给出的例子：

1. 直接使用：
   使用 Sequential 创建一个模型时，只需将所需的层按顺序放入即可。如例中所示，模型按顺序执行两个卷积层和两个ReLU激活层。

model = nn.Sequential(
    nn.Conv2d(1, 20, 5),
    nn.ReLU(),
    nn.Conv2d(20, 64, 5),
    nn.ReLU()
)

2. 使用 OrderedDict：
   如果需要在 Sequential 中指定层的名称，可以使用 OrderedDict 来创建。这样做的好处是你可以为每个层指定一个独特的名字，这在调试和查看模型结构时非常有帮助。

from collections import OrderedDict

model = nn.Sequential(OrderedDict([
    ('conv1', nn.Conv2d(1, 20, 5)),
    ('relu1', nn.ReLU()),
    ('conv2', nn.Conv2d(20, 64, 5)),
    ('relu2', nn.ReLU())
]))

4.实际使用场景下的综合实例

nn.Sequential 在 PyTorch 中是一个非常有用的容器，用于自动化的处理一系列模块的前向传播。它将多个神经网络模块封装为一个统一的整体，使得整个模块的处理流程自动化和序列化，并且可以通过简单的方式进行操作和理解。这里我们通过一个实际的例子来深入解释 nn.Sequential 的用法以及其与 torch.nn.ModuleList 的区别。

理解 nn.Sequential 的本质作用

通过 nn.Sequential，可以将不同的网络层（如卷积层、批量归一化层和激活函数）按顺序组合在一起，形成一个整体的模块。这样，输入数据可以依次通过这些层，每层的输出自动成为下一层的输入，最后输出最终的结果。

示例代码解释
在下面的示例中，我们定义了一个神经网络 net，该网络包含三个通过 nn.Sequential 封装的层。

from torch import nn

class Net(nn.Module):
    def __init__(self, in_channel, out_channel):
        super(Net, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(in_channel, int(in_channel / 4), kernel_size=1),
            nn.BatchNorm2d(int(in_channel / 4)),
            nn.ReLU()
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(int(in_channel / 4), int(in_channel / 4), kernel_size=3, padding=1),
            nn.BatchNorm2d(int(in_channel / 4)),
            nn.ReLU()
        )
        self.layer3 = nn.Sequential(
            nn.Conv2d(int(in_channel / 4), out_channel, kernel_size=1),
            nn.BatchNorm2d(out_channel),
            nn.ReLU()
        )
    
    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x

代码组成:

• self.layer1: 包括一个 1x1 的卷积层，接着是批量归一化和ReLU激活函数。
• self.layer2: 包含一个 3x3 的卷积层（保持输入输出尺寸一致，使用了填充），也接着是批量归一化和ReLU激活。
• self.layer3: 最后是另一个 1x1 卷积层转换到所需的输出通道数，随后是批量归一化和ReLU激活。

5.总结

这种布局清晰地展示如何将复杂的图层组合简化为可重用的模块。 nn.Sequential: 此容器存储模块并自动按顺序执行每个模块的前向传播。这意味着在 Sequential 中添加的模块必须按照严格的输入和输出顺序连接。使用 nn.Sequential 可以极大地简化代码，特别是在模型层次结构比较直观且线性的情况下。它不仅增强了代码的可读性，还减少了潜在的编程错误，使得整体网络结构的管理更为高效。