1. 初识torch.nn.Sequential：你的神经网络“流水线”

如果你刚开始接触PyTorch，面对着一堆nn.Linear、nn.Conv2d、nn.ReLU这些层，可能会有点不知所措：我该怎么把它们串起来？难道要像搭积木一样，在forward函数里手动写十几行代码，把每一层的输出传给下一层吗？

别担心，PyTorch早就为你准备好了“流水线”工具——torch.nn.Sequential。你可以把它想象成一个乐高积木的说明书，或者一条工厂里的装配线。你只需要按照顺序，把需要的神经网络层（积木）放进去，Sequential就会自动帮你把它们首尾相连，组装成一个完整的模型。

我刚开始用PyTorch那会儿，也喜欢在forward里手动写流程，觉得这样控制力强。但后来项目里的网络越来越复杂，动辄几十层，每次修改结构或者调试中间输出都特别麻烦。直到我发现了Sequential，才真正体会到什么叫“开发效率”。它把模型的结构定义变得像列清单一样简单直观。

它到底是什么？ 简单说，nn.Sequential是PyTorch nn.Module的一个子类，是一个有序的容器。你传入的模块（层）会按照它们在构造函数中出现的顺序，被依次添加到这个容器里。当数据（输入张量）流入这个容器时，它会严格按照你定义的顺序，依次经过每一个模块，前一个模块的输出就是后一个模块的输入，最终得到整个模型的输出。

它的核心价值在于封装和简化。原本你需要定义一个继承自nn.Module的类，并在forward方法中显式地调用每一层。现在，你只需要一行代码就能定义一个完整的子网络或整个模型，代码可读性大大提升，调试起来也方便得多。

举个例子，假设我们要构建一个简单的图像分类网络，包含卷积、激活、池化、再卷积、再激活、最后展平并全连接。用传统方法和Sequential对比一下：

# 方法一：传统继承 nn.Module 的方式
class MyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(2)
        self.flatten = nn.Flatten()
        self.fc = nn.Linear(32 * 8 * 8, 10) # 假设输入是32x32的图片

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.pool2(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

# 方法二：使用 Sequential
model = nn.Sequential(
    nn.Conv2d(3, 16, 3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(16, 32, 3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Flatten(),
    nn.Linear(32 * 8 * 8, 10)
)

看出来了吗？第二种方法不仅代码行数少了一半，而且结构一目了然，从上到下就是数据流动的路径。这对于快速原型设计、教学或者构建一些标准的、线性的网络块（如VGG中的连续卷积块）来说，简直是神器。

2. 三种构建方式：从简单到灵活

nn.Sequential提供了几种不同的构建方式，适应不同的使用场景和代码风格。我建议你都了解一下，因为在不同的项目中可能会用到。

2.1 直接参数列表：最快捷的方式

这是最常用、最直观的方法。就像上面的例子一样，直接把层作为参数按顺序传给Sequential的构造函数。

import torch.nn as nn

# 构建一个简单的多层感知机 (MLP)
mlp = nn.Sequential(
    nn.Linear(784, 256),  # 第一层：784维输入 -> 256维隐藏层
    nn.ReLU(),            # 激活函数
    nn.Dropout(0.2),      # Dropout层，防止过拟合
    nn.Linear(256, 128),  # 第二层：256 -> 128
    nn.ReLU(),
    nn.Linear(128, 10),   # 输出层：128 -> 10（例如10分类）
    nn.LogSoftmax(dim=1)  # 输出概率分布（对数形式）
)

print(mlp)

运行这段代码，你会看到类似这样的输出：

Sequential(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Dropout(p=0.2, inplace=False)
  (3): Linear(in_features=256, out_features=128, bias=True)
  (4): ReLU()
  (5): Linear(in_features=128, out_features=10, bias=True)
  (6): LogSoftmax(dim=1)
)

这种方式非常清晰，但有一个小缺点：每一层都是用默认的数字索引（0, 1, 2...）来标识的。当你想要单独访问或修改某一层时，需要记住它的位置索引，比如mlp[3]来访问第二个全连接层。对于小型网络这没问题，但层数多了就容易搞混。

2.2 使用OrderedDict：给每一层起个名字

为了解决索引不直观的问题，我们可以使用collections.OrderedDict来构建Sequential。OrderedDict是一个能记住键值对插入顺序的字典。这样，我们就可以给每一层起一个有意义的名字。

from collections import OrderedDict
import torch.nn as nn

model = nn.Sequential(OrderedDict([
    ('conv1', nn.Conv2d(1, 20, 5)),   # 命名为 conv1
    ('relu1', nn.ReLU()),             # 命名为 relu1
    ('pool1', nn.MaxPool2d(2)),       # 命名为 pool1
    ('conv2', nn.Conv2d(20, 64, 5)),  # 命名为 conv2
    ('relu2', nn.ReLU()),             # 命名为 relu2
    ('pool2', nn.MaxPool2d(2)),       # 命名为 pool2
    ('flatten', nn.Flatten()),        # 命名为 flatten
    ('fc', nn.Linear(1024, 10))       # 命名为 fc (全连接层)
]))

print(model)

输出会变成：

Sequential(
  (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  (relu1): ReLU()
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  (relu2): ReLU()
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (fc): Linear(in_features=1024, out_features=10, bias=True)
)

现在，层的结构一目了然。更重要的是，你可以通过名字直接访问特定层，比如model.conv1或者model['conv1']，这比model[0]要直观太多了。这在后续的模型分析、特征提取或者微调特定层时非常有用。

2.3 动态构建：使用add_module方法

有时候，我们可能需要在代码运行过程中动态地添加层，而不是一开始就定义好所有层。Sequential也支持这种操作，因为它继承自nn.Module，所以拥有add_module方法。

model = nn.Sequential()
# 逐步添加层
model.add_module('conv1', nn.Conv2d(3, 64, 3, padding=1))
model.add_module('bn1', nn.BatchNorm2d(64))  # 添加批归一化
model.add_module('relu1', nn.ReLU(inplace=True))
model.add_module('pool1', nn.MaxPool2d(2))

# 再添加一个卷积块
model.add_module('conv2', nn.Conv2d(64, 128, 3, padding=1))
model.add_module('bn2', nn.BatchNorm2d(128))
model.add_module('relu2', nn.ReLU(inplace=True))
model.add_module('pool2', nn.MaxPool2d(2))

print(model)

这种方式在根据某些条件（比如配置文件、用户输入）动态构建网络时特别有用。比如，你可以写一个循环，根据一个列表中的层配置来动态添加层。

三种方式怎么选？ 我的经验是：

• 快速实验、简单网络：直接用参数列表，最省事。
• 中大型项目、需要清晰结构和后续访问：用OrderedDict，可读性和可维护性最好。
• 需要动态、灵活构建网络结构：用add_module方法。

3. 玩转Sequential：访问、修改与遍历

把模型建好只是第一步，我们还得知道怎么“摆弄”它。Sequential本质上是一个有序的容器，所以它支持很多类似Python列表（List）的操作，这让它用起来非常顺手。

3.1 像列表一样索引和切片

你可以用整数索引来访问Sequential中的任何一层。

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 30),
    nn.Tanh(),
    nn.Linear(30, 5)
)

# 访问第一层
first_layer = model[0]
print(f"第一层: {first_layer}")
# 输出: Linear(in_features=10, out_features=20, bias=True)

# 访问最后一层
last_layer = model[-1]
print(f"最后一层: {last_layer}")
# 输出: Linear(in_features=30, out_features=5, bias=True)

# 甚至可以使用切片，获取一个子序列（返回的是一个新的Sequential）
sub_model = model[1:4]  # 获取第1,2,3层（索引1到3）
print(f"子模型: {sub_model}")
# 输出: Sequential(
#   (0): ReLU()
#   (1): Linear(in_features=20, out_features=30, bias=True)
#   (2): Tanh()
# )

这个特性在模型手术时特别有用。比如你想看看某个中间层的输出，或者想把预训练模型的前几层冻结（不更新参数），直接索引取出那几层就行。

3.2 动态修改：替换、插入和删除

模型不是一成不变的，Sequential允许你在创建后动态修改其结构。

# 假设我们有一个初始模型
model = nn.Sequential(
    nn.Linear(10, 50),
    nn.Sigmoid(),  # 我们后来觉得Sigmoid不好
    nn.Linear(50, 1)
)

print("修改前:", model)

# 1. 替换某一层：把Sigmoid换成ReLU
model[1] = nn.ReLU()
print("替换激活层后:", model)

# 2. 插入新层：在第二层后插入一个Dropout层
# 注意：`insert`方法会修改原模型，并返回修改后的模型自身（便于链式调用）
model.insert(2, nn.Dropout(0.3))
print("插入Dropout后:", model)

# 3. 删除某一层：删除我们刚插入的Dropout层
del model[2]
print("删除Dropout后:", model)

# 4. 在末尾追加新层
model.append(nn.Sigmoid())  # 在最后加一个Sigmoid，将输出映射到(0,1)区间
print("末尾追加Sigmoid后:", model)

# 5. 获取模型长度（层数）
print(f"模型总层数: {len(model)}")

这里有个坑我踩过：insert和append方法会直接修改原模型，而不是返回一个新模型。这和Python列表的insert、append行为一致，但如果你习惯了PyTorch中很多操作不修改原张量的习惯，这里需要注意一下。

3.3 遍历所有层

你可以像遍历列表一样遍历Sequential中的所有层，这在初始化参数、批量操作时很方便。

# 遍历并打印每一层的信息
for idx, layer in enumerate(model):
    print(f"第{idx}层: {layer}, 参数数量: {sum(p.numel() for p in layer.parameters())}")

# 一个实用的例子：初始化所有权重（使用Kaiming初始化）
def init_weights(m):
    if isinstance(m, nn.Linear):
        nn.init.kaiming_uniform_(m.weight, nonlinearity='relu')
        if m.bias is not None:
            nn.init.constant_(m.bias, 0)

# 将初始化函数应用到模型的每一层
model.apply(init_weights)

apply方法是nn.Module的方法，它会递归地将函数应用到自身及其所有子模块。结合Sequential的线性结构，我们可以轻松地对所有层进行统一操作，比如权重初始化、梯度裁剪等。

4. 高级技巧与实战应用

掌握了基本操作，我们来看看Sequential在实战中一些更高级的用法和技巧。这些技巧能帮你写出更优雅、更强大的代码。

4.1 嵌套使用：构建模块化网络

Sequential本身也是一个nn.Module，所以它可以作为另一个Sequential或者自定义模型的一部分。这种嵌套能力让我们可以轻松地构建模块化的网络。

想象一下，你在构建一个复杂的ResNet或Transformer。你可以把重复出现的结构块（比如ResNet的BasicBlock，Transformer的EncoderLayer）用Sequential封装起来，然后在主网络里像搭积木一样使用它们。

def make_conv_block(in_channels, out_channels, kernel_size=3, stride=1, padding=1):
    """定义一个标准的卷积块：Conv -> BN -> ReLU -> Pool"""
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding),
        nn.BatchNorm2d(out_channels),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(2)
    )

# 构建一个由多个卷积块组成的特征提取器
feature_extractor = nn.Sequential(
    make_conv_block(3, 64),      # 块1: 3 -> 64
    make_conv_block(64, 128),    # 块2: 64 -> 128
    make_conv_block(128, 256),   # 块3: 128 -> 256
    nn.AdaptiveAvgPool2d((1, 1)), # 全局平均池化
    nn.Flatten()
)

# 构建完整的分类模型
classifier = nn.Sequential(
    nn.Linear(256, 128),  # 假设feature_extractor输出256维特征
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(128, 10)    # 10分类
)

# 组合成最终模型
model = nn.Sequential(
    feature_extractor,
    classifier
)

print(model)

这样做的好处是代码复用性高，结构清晰。如果你想修改所有卷积块的结构，只需要改make_conv_block函数一处。而且，你可以很方便地通过model[0]访问整个特征提取器，或者通过model[0][1]访问第二个卷积块。

4.2 与nn.ModuleList和nn.ModuleDict的对比

PyTorch还有其他容器，比如nn.ModuleList和nn.ModuleDict。它们和Sequential有什么区别？什么时候该用哪个？

特性	nn.Sequential	nn.ModuleList	nn.ModuleDict
核心用途	顺序执行模块，自动定义forward	存储模块列表，不定义forward	存储模块字典，不定义forward
数据流	严格的、线性的前向传播	需要手动在forward中定义数据流	需要手动在forward中定义数据流
访问方式	整数索引、切片、属性名（如果命名了）	整数索引、切片	字符串键
适用场景	线性堆叠的网络（如VGG、简单MLP）	需要循环或条件执行的层集合	需要通过名字动态选择或访问的模块集合

简单来说：

• 用Sequential：当你的网络层是简单的、线性的“一条路走到黑”时。
• 用ModuleList：当你有一组层，但它们的执行顺序不是固定的，或者需要在forward里用循环处理（比如堆叠多个相同的层，但中间可能有跳连）。
• 用ModuleDict：当你需要通过字符串键名来动态选择使用哪个模块时。

举个例子，如果你想实现一个有多条分支的网络（像Inception模块），或者有跳跃连接（像ResNet），Sequential就不够用了，因为它的数据流是严格单向的。这时你就需要继承nn.Module自己写forward函数，并在里面使用ModuleList或ModuleDict来管理你的层。

4.3 调试与可视化：查看中间输出

调试神经网络时，经常需要查看某一层的输出，以确定问题出在哪里。Sequential的索引特性让这变得很容易。

# 假设我们有一个训练好的模型，但效果不好，想看看中间某层的输出
test_input = torch.randn(1, 3, 32, 32)  # 一个测试样本

# 方法1：手动执行到指定层
intermediate_output = test_input
for i in range(4):  # 只运行到第4层（索引3）
    intermediate_output = model[i](intermediate_output)
print(f"运行到第4层后的输出形状: {intermediate_output.shape}")

# 方法2：使用切片创建一个子模型（更优雅）
sub_model = nn.Sequential(*list(model.children())[:4])  # 取前4层
intermediate_output = sub_model(test_input)
print(f"子模型输出形状: {intermediate_output.shape}")

# 更高级的：注册钩子（hook）来捕获任意层的输出（不修改模型结构）
def hook_fn(module, input, output):
    print(f"{module.__class__.__name__} 层的输出形状: {output.shape}")
    # 这里还可以保存输出、计算统计量等

# 为模型的第三层（索引2）注册一个前向钩子
handle = model[2].register_forward_hook(hook_fn)

# 运行前向传播，钩子会自动被调用
final_output = model(test_input)

# 记得移除钩子，避免内存泄漏
handle.remove()

钩子（Hook） 是一个非常强大的调试和可视化工具。除了打印形状，你还可以用它来可视化特征图、计算层的梯度分布、实现一些特殊的正则化等等。不过要注意，钩子会增加运行开销，在最终部署的代码中记得移除。

5. 避坑指南与最佳实践

用了这么多年Sequential，我也踩过不少坑。这里总结几个常见的注意事项和最佳实践，希望能帮你少走弯路。

5.1 输入输出形状匹配：最常见的错误

这是新手（包括当年的我）最容易出错的地方。Sequential要求每一层的输出形状必须与下一层的输入形状严格匹配。

# 一个会出错的例子
wrong_model = nn.Sequential(
    nn.Conv2d(3, 16, 3),       # 输出形状: (N, 16, H-2, W-2)
    nn.Flatten(),              # 这里直接展平，但不知道展平后的维度是多少！
    nn.Linear(?, 10)           # Linear层需要明确的输入特征数，这里无法确定
)

上面的代码会报错，因为Flatten层不知道输入张量的空间尺寸（H, W），所以无法确定展平后的特征数，导致后面的Linear层无法初始化。

解决方案：

1. 手动计算：根据输入尺寸和每一层的参数，推算出最终的特征数。
2. 使用自适应层：比如nn.AdaptiveAvgPool2d(1)，它可以将任意尺寸的特征图池化到1x1，然后再接Flatten和Linear。
3. 先试运行：用一个虚拟输入（dummy input）跑一遍模型，看看每一层的输出形状。

# 正确的做法：使用自适应池化
correct_model = nn.Sequential(
    nn.Conv2d(3, 16, 3),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(16, 32, 3),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d((1, 1)),  # 输出固定为 (N, 32, 1, 1)
    nn.Flatten(),                   # 展平为 (N, 32)
    nn.Linear(32, 10)               # 输入特征数明确为32
)

# 用虚拟输入测试
dummy_input = torch.randn(4, 3, 32, 32)  # 批量大小4，3通道，32x32图像
try:
    output = correct_model(dummy_input)
    print(f"模型运行成功！输出形状: {output.shape}")
except Exception as e:
    print(f"模型运行出错: {e}")

5.2 合理使用命名：提升代码可读性

对于稍微复杂一点的模型，强烈建议使用OrderedDict或add_module给层命名。这不仅仅是好看，在后续的模型分析、微调、特征提取时，能省去大量查找索引的麻烦。

# 好的实践：清晰的命名
good_model = nn.Sequential(OrderedDict([
    ('stem', nn.Sequential(  # 给整个“茎部”块命名
        nn.Conv2d(3, 64, 7, stride=2, padding=3),
        nn.BatchNorm2d(64),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(3, stride=2, padding=1)
    )),
    ('layer1', make_conv_block(64, 128)),  # 调用之前定义的函数
    ('layer2', make_conv_block(128, 256)),
    ('global_pool', nn.AdaptiveAvgPool2d(1)),
    ('flatten', nn.Flatten()),
    ('classifier', nn.Sequential(
        nn.Dropout(0.5),
        nn.Linear(256, 128),
        nn.ReLU(),
        nn.Linear(128, 10)
    ))
]))

# 现在访问起来非常直观
print(good_model.stem[0])  # 访问stem块的第一个卷积层
print(good_model.classifier[-1])  # 访问分类器的最后一层

5.3 理解局限性：何时不用Sequential

Sequential虽好，但并非万能。它的核心局限在于严格线性的数据流。如果你的网络结构有以下特点，Sequential可能就不太合适了：

1. 跳跃连接（Skip Connections）：像ResNet那样，需要把前面某层的输出加到后面某层的输出上。
2. 多输入或多输出：模型有多个输入流，或者需要输出多个结果（比如目标检测模型同时输出类别和边界框）。
3. 条件分支：网络结构需要根据输入数据或中间结果动态变化。
4. 层共享：同一个层实例需要在网络的不同位置被多次使用。

对于这些复杂结构，你需要继承nn.Module来定义自己的模型类，并在forward方法中手动编写数据流的逻辑。

# 一个简单的残差块示例，无法用Sequential直接实现
class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, padding=1)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        # 捷径连接（shortcut），如果维度变化则需要1x1卷积调整
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, stride),
                nn.BatchNorm2d(out_channels)
            )
    
    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += self.shortcut(identity)  # 跳跃连接在这里！
        out = self.relu(out)
        return out

# 在主网络中使用这个残差块
class MyResNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(3, stride=2, padding=1),
            ResidualBlock(64, 64),  # 这里可以放自定义模块
            ResidualBlock(64, 128, stride=2),
            ResidualBlock(128, 256, stride=2),
        )
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.classifier = nn.Linear(256, 10)
    
    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

在这个例子中，我们结合了Sequential和自定义Module。Sequential用于组织线性的部分（如初始卷积层），而复杂的、有跳跃连接的部分则用自定义的ResidualBlock实现。这种混合方式既保持了代码的简洁性，又提供了足够的灵活性。

5.4 性能与部署考量

在大多数情况下，Sequential和手动编写forward在性能上没有区别。因为PyTorch的图优化和JIT编译最终处理的是计算图，而不是你的Python代码结构。

但是，有一点需要注意：如果你使用torch.jit.script或torch.jit.trace来将模型导出为TorchScript（用于生产环境部署），要确保你的Sequential结构是静态的、可追踪的。动态地修改Sequential（比如在forward里根据条件改变层）可能会导致追踪失败。

对于生产部署，一个良好的实践是：使用Sequential定义稳定的、线性的子结构，而对于需要动态逻辑的部分，则使用标准的nn.Module并确保其逻辑可以被TorchScript正确编译。

最后，记住Sequential是你的工具，而不是束缚。它的设计目的是为了简化常见任务，而不是限制你的创造力。在PyTorch的生态里，灵活性和易用性往往可以兼得。当你熟练掌握了Sequential的用法后，你会发现它能让你的模型代码更加整洁、高效，让你能把更多精力集中在算法设计和调优上，而不是繁琐的样板代码上。