从零搭建简单卷积网络：PyTorch实现与训练实战

1. 从“会算卷积”到“会搭网络”：缺的到底是什么

前面两篇把卷积的底层运算、卷积核、padding、stride、通道数这些概念梳理了一遍，但说实话，光会算单个卷积层是搭不出一个能用的模型的。很多人卡在同一个地方：每个概念单独拿出来都懂，一旦要把它们组合成一个完整的卷积网络，就不知道从哪里下手。我自己带过不少新人，这个问题见得太多了。这篇就把“简单卷积网络”这件事彻底讲清楚，从结构设计到代码实现，再到训练时最容易踩的坑，一篇走完。

简单卷积网络，就是指用少量卷积层、池化层、全连接层堆叠出来的基础CNN。它虽然结构简单，但包含了现代深度学习视觉模型的所有核心要素。理解了它，后面再看ResNet、DenseNet、EfficientNet这些复杂结构，你会发现它们都是在简单卷积网络骨架上做文章。所以这篇讲的内容不是“过时的玩具”，而是一切的起点。

这篇适合两类人：一类是正在学深度学习、刚把卷积运算搞明白的初学者，另一类是已经会用现成模型但从来没自己从头搭过网络的开发者。对于前者，这篇文章给你一个完整可运行的网络和训练流程，照着敲一遍就能跑起来；对于后者，我重点讲结构设计背后的逻辑和训练调参时的真实经验，这些是文档里查不到的。

我会用PyTorch作为实现工具，讲一个在Fashion-MNIST数据集上做图像分类的完整案例。选这个数据集是因为它比手写数字识别稍微有挑战性一点，但又不至于像ImageNet那样需要大规模分布式训练。网络结构只有四层卷积加一个全连接层，单张显卡几分钟就能跑完一个epoch，非常适合用来理解卷积网络的完整工作流程。

2. 简单卷积网络的三个积木块：卷积层、池化层、全连接层怎么各司其职

2.1 卷积层：在“局部”里提取特征

一个简单的卷积网络，第一个积木块必然是卷积层。卷积层做的事情可以概括为一句话：在局部区域里做模式匹配。

为什么强调“局部”？因为图像数据有一个天然的特性：相邻像素之间的相关性远大于相距较远的像素。你要识别一张图片里有没有“眼睛”，不需要看整张图，只需要看眼睛所在的那个局部区域就够了。卷积层正是利用了这一特性，用一个小尺寸的卷积核（常见3×3或5×5）在整个输入上滑窗扫描，提取局部特征。

在一层卷积中，有几个关键参数需要理解：

• 输入通道数（in_channels）：上一层输出的特征图数量。对第一层来说，就是图像的通道数，RGB图为3，灰度图为1。
• 输出通道数（out_channels）：本层使用的卷积核数量。每个卷积核会生成一张新的特征图，所以输出通道数等于卷积核数量。
• 卷积核尺寸（kernel_size）：每个卷积核的感受野大小。3×3是最常用的，因为两个3×3卷积叠加的有效感受野等于一个5×5卷积，但参数量更少。
• 步长（stride）：卷积核每次滑动的像素数。步长为1时输出尺寸变化主要由padding决定，步长为2时特征图尺寸直接减半，可以起到下采样作用。
• 填充（padding）：在输入边缘补零，常用于保持输出尺寸不变。

这里有一个新手常搞混的点：输出通道数不是“这层能识别多少种特征”的上限，而是“这层同时提取了多少种不同的特征模式”。每个卷积核初始是随机的，训练过程中会逐渐变成某种特定模式的检测器（比如边缘检测器、纹理检测器）。32个卷积核意味着这层在找32种不同的局部模式。通道数设定得越大，网络的表达能力越强，但参数量和计算量也越大，且超过一定规模后收益递减。

2.2 池化层：压缩信息，提取“最显著”的特征

第二个积木块是池化层。池化层不包含任何需要学习的参数，它的作用是对特征图进行下采样。最常见的两种是最大池化（Max Pooling）和平均池化（Average Pooling）。

最大池化的操作非常简单：在2×2的窗口内取最大值作为输出。这样特征图的宽高各减半，整体尺寸缩小到原来的四分之一。为什么取最大值而不是平均值？因为在图像特征提取中，某个位置只要存在强响应，就说明该区域有对应的特征模式。最大池化保留了这种“有还是没有”的信息，同时丢弃了精确位置信息。这种位置不敏感性对图像分类是有益的——一个物体稍稍平移几个像素，分类结果不应该改变。

提示：池化的本质是牺牲空间分辨率换取平移不变性。对分类任务来说这是好事，但对目标检测、图像分割这种需要精确定位的任务，过早或过度池化会丢失位置信息，这也是后来语义分割模型普遍使用空洞卷积或编码器-解码器结构的原因。

平均池化到后期用得相对少一些，不过在全局平均池化（Global Average Pooling）这个特殊形式下非常有用：把整张特征图压缩成一个值，输出通道数就是特征向量长度，可以直接接分类层。这个技巧在很多现代网络里取代了全连接层，因为它不会破坏空间结构，而且天然带有正则化效果。

2.3 全连接层：把“特征”变成“结论”

第三个积木块是全连接层。全连接层的作用是把卷积层和池化层提取到的特征图“展平”后，映射到最终的输出空间。

以图像分类为例，假设输入是10个类别的图片，那么全连接层的输出就是10个数，每个数代表该图片属于某个类别的“得分”。全连接层做的事情，本质上是对前面提取到的特征做加权求和，然后经过激活函数（如Softmax）变成概率分布。

全连接层的参数量计算方式很简单：输入维度乘以输出维度。比如输入是512维的特征，输出是10个类别，这一层就有512×10+10=5130个参数。看起来不多，但要注意，如果前面的卷积部分输出尺寸很大（比如7×7×512），展平后就变成25088维，再接一个1024维的全连接层，参数就变成了25088×1024，约2500万个参数。这也是为什么大部分CNN参数量都集中在全连接层的原因。

这里要记住一个关键点：卷积网络的主体特征提取器是卷积层和池化层，全连接层只是“分类头”。在实际工程中，如果数据量不够大，全连接层往往是过拟合的重灾区，因为它参数量太大、没有利用局部空间结构。现代模型更倾向于用全局平均池化+少量全连接层，或者干脆用1×1卷积来做分类。

2.4 激活函数：给网络引入非线性

虽然不算一个独立“层”，但每次卷积操作后面几乎都要跟一个激活函数，这个在搭建网络时不能省略。如果去掉激活函数，无论网络多深，叠加起来本质上还是一个线性变换，表达能力会大打折扣。

早期常用的激活函数是Sigmoid和tanh，但它们在深层网络中会导致梯度消失——层数越深，反向传播时梯度越小，前面的层几乎学不到东西。后来ReLU（Rectified Linear Unit）成了主流选择，它形式简单：输入大于0时输出等于输入，小于0时输出为0。ReLU的梯度在正区间恒为1，有效缓解了梯度消失问题，计算也极快。

ReLU有个变体叫LeakyReLU，在负数区间给一个很小的斜率（比如0.01），避免某些神经元“死掉”。死掉是指某个神经元对所有输入都输出0，梯度也为0，此后再也无法更新。这个问题在实际训练中确实会遇到，尤其是学习率设置不当时。对简单卷积网络来说，ReLU基本够用；如果发现训练过程中很多神经元输出都是0，可以换成LeakyReLU试试。

3. 动手搭一个能跑通的四层卷积网络：结构和代码逐行拆解

3.1 为什么选四层卷积加一层全连接

网络层数选择没有绝对标准，但有一个基本逻辑：层数太少，特征提取能力不足；层数太多，训练难度急剧上升。对Fashion-MNIST这种28×28的灰度图，四层卷积是比较合适的起点。

Fashion-MNIST有10个类别，包括T恤、裤子、外套、连衣裙、衬衫、鞋、运动鞋、包、踝靴等。这些物品与手写数字相比，纹理和轮廓信息更丰富，需要稍微复杂一点的特征提取过程。我见过很多用两层卷积在这个数据集上只能做到90%左右准确率的例子，四层卷积可以比较轻松地达到92%-93%，如果加一些正则化技巧还能更高。

28×28输入图经过四层卷积和池化后的尺寸变化需要考虑清楚。这张表我在设计网络时会先算出来，避免后面展平时尺寸对不上报错：

这个设计的逻辑是：随着网络加深，特征图的空间尺寸逐渐减小，但通道数逐渐增加。这反映了特征提取的层级性：浅层提取低级特征（边缘、纹理），深层组合出高级语义特征（衣领、袖口、鞋底）。通道数递增是因为每个层的特征模式应该更细分，但空间位置的信息已经通过池化逐步压缩。

3.2 完整的PyTorch实现代码

直接看代码。以下是用PyTorch实现上述网络的完整代码，我在关键位置加了注释说明：

python复制import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()

        # 第一层：输入1通道（灰度图），输出32通道
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32,
                               kernel_size=3, padding=1)
        # 第二层：输入32通道，输出64通道
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64,
                               kernel_size=3, padding=1)
        # 第三层：输入64通道，输出128通道
        self.conv3 = nn.Conv2d(in_channels=64, out_channels=128,
                               kernel_size=3, padding=1)
        # 第四层：输入128通道，输出128通道
        self.conv4 = nn.Conv2d(in_channels=128, out_channels=128,
                               kernel_size=3, padding=1)

        # 池化层：统一用2x2最大池化，stride默认为2
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)

        # 全连接层：输入为128*7*7（展平后），输出为10类
        self.fc = nn.Linear(in_features=128*7*7, out_features=num_classes)

    def forward(self, x):
        # 第一组：卷积+激活+池化
        x = self.pool(F.relu(self.conv1(x)))
        # 第二组：卷积+激活+池化
        x = self.pool(F.relu(self.conv2(x)))
        # 第三组：卷积+激活（不再池化，保持7x7）
        x = F.relu(self.conv3(x))
        # 第四组：卷积+激活（不再池化，保持7x7）
        x = F.relu(self.conv4(x))

        # 展平：从 (batch_size, 128, 7, 7) 变成 (batch_size, 128*7*7)
        x = x.view(x.size(0), -1)
        # 全连接分类
        x = self.fc(x)
        return x

这段代码有几个值得注意的地方：

第三层和第四层之后我没有再接池化。原因很简单：输入7×7的特征图如果再做一次2×2池化，尺寸会变成3×3，信息损失太大。7×7总共49个位置，压缩到3×3的9个位置，保留的信息堪忧。在实际设计中，7×7的尺寸对高层语义特征来说已经足够紧凑，直接展平接全连接层是合理的。

全连接层输入维度128×7×7=6272，这个数字是手算出来的。如果稍微改动前面某一层卷积的padding或stride，这个数字就要重新计算。所以在搭建网络时，我建议写一段测试代码，随机生成一个输入张量过一遍forward，确认输出形状符合预期再开始训练。

3.3 为什么用view而不是reshape

代码里我用x.view(x.size(0), -1)做展平，这是PyTorch里最常见的写法。view方法的作用是返回一个新的张量视图，不复制数据。x.size(0)取的是batch size维度，-1表示自动计算这个维度的大小。对形状为(batch_size, 128, 7, 7)的张量，view(batch_size, -1)会变成(batch_size, 6272)。

PyTorch还有reshape方法，功能类似，但view要求张量在内存中是连续的。经过卷积操作后的张量通常已经是连续的，所以这里用view没问题。如果遇到“View is not contiguous”的报错，说明张量在内存中不连续，需要用contiguous()方法处理一下。我自己习惯在view前加一个contiguous()来避免这个问题，虽然会有些微性能开销：

python复制x = x.contiguous().view(x.size(0), -1)

这不是必须的，但能省去一些莫名其妙的报错排查时间。

3.4 初始化网络并检查输出

搭好网络后，第一件事不是训练，而是验证网络结构是否正确。我习惯写一段测试代码：

python复制# 创建网络实例
model = SimpleCNN(num_classes=10)
print(model)

# 用随机数据测试前向传播
test_input = torch.randn(2, 1, 28, 28)  # batch=2, 1通道, 28x28
output = model(test_input)
print(f"输入形状: {test_input.shape}")
print(f"输出形状: {output.shape}")
# 期望输出形状: torch.Size([2, 10])

如果输出形状是[2, 10]，说明网络结构没问题。这一步能帮你提前发现尺寸不匹配的问题，而不是等到训练时才报错。输出层后面一般不再接Softmax，因为PyTorch的CrossEntropyLoss内部已经包含了Softmax运算。如果手动在输出层加了Softmax，再用CrossEntropyLoss，会造成重复计算，导致训练效果异常。

4. 训练配置与核心步骤：损失函数、优化器、batch size和评估逻辑

4.1 数据加载与预处理

Fashion-MNIST数据集在torchvision里可以直接下载。数据处理有两个关键点：一是要将像素值归一化到0到1之间，二是要转成Tensor格式。

python复制import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = torchvision.datasets.FashionMNIST(
    root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.FashionMNIST(
    root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=2)

Normalize((0.5,), (0.5,))的意思是对每个像素做(x-0.5)/0.5的变换，把0到1的像素值映射到-1到1的范围。这种中心化处理能加速模型收敛。注意ToTensor()会自动把像素值从0-255缩放到0-1，所以Normalize的均值0.5和标准差0.5都是在这个前提下的。

为什么要用batch而不是一次把所有数据都喂进模型？两个原因：一是内存放不下，Fashion-MNIST训练集有6万张图，一次性加载会对显存构成较大压力；二是小批量训练引入了随机性，这种随机性带来的噪声实际上有助于模型跳出局部最优点，泛化效果往往更好。batch size选64是经验值，这个数据集上用64或128训练出来的模型差距不大，但batch太小（如8或16）会导致梯度估计不准确，收敛过程会很颠簸。

4.2 损失函数、优化器和学习率的选择思路

对多分类任务，损失函数直接用交叉熵损失（CrossEntropyLoss）。前面提到，PyTorch的CrossEntropyLoss已经内置了Softmax，所以网络最后一层输出的原始得分（logits）直接传入即可。

优化器我推荐用Adam，因为它是自适应学习率的方法，对初学者友好，不容易因为学习率设置不当导致训练完全发散。但Adam有一个问题：得到的模型有时泛化性能略低于经过精心调参的SGD。对这篇入门级的网络，我建议先用Adam验证流程，后期如果有精力，可以对比SGD加momentum的效果。

学习率方面，Adam一般用1e-3，SGD加momentum一般用0.01到0.1。我的经验是：如果loss在训练初期就出现NaN，或者剧烈震荡，先检查学习率是不是太大。如果loss下降非常缓慢，可能是学习率太小。再补充一个经验：训练时可以先用一个小数据集（比如1000张图）做一次过拟合测试。如果模型在这1000张图上都无法收敛，说明代码有bug或学习率设置有问题，这时候在完整数据集上反复调参只会浪费时间。

python复制import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

4.3 训练循环的标准写法

训练循环是每次都要写的样板代码，我把一个完整的训练加验证版本贴出来，关键地方加上了解释：

python复制def train_one_epoch(model, train_loader, criterion, optimizer, device):
    model.train()  # 切换到训练模式
    running_loss = 0.0
    correct = 0
    total = 0

    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)

        # 清零梯度：PyTorch默认会累积梯度，必须在每次迭代前清零
        optimizer.zero_grad()

        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播 + 参数更新
        loss.backward()
        optimizer.step()

        # 统计loss和准确率
        running_loss += loss.item() * images.size(0)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    epoch_loss = running_loss / total
    epoch_acc = correct / total
    return epoch_loss, epoch_acc

def evaluate(model, test_loader, criterion, device):
    model.eval()  # 切换到评估模式
    running_loss = 0.0
    correct = 0
    total = 0

    with torch.no_grad():  # 评估时不需要计算梯度，节省内存和计算
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            loss = criterion(outputs, labels)

            running_loss += loss.item() * images.size(0)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    epoch_loss = running_loss / total
    epoch_acc = correct / total
    return epoch_loss, epoch_acc

这段代码里有一个很容易被忽视的细节：model.train()和model.eval()的区别。对当前这个简单CNN来说，这两种模式没有区别，因为网络里没有Dropout层和BatchNorm层。但一旦网络结构里加入了这两个层，忘记切换模式会导致训练和测试结果莫名其妙地不对。养成每次训练前和评估前都明确调用对应方法的习惯，是省时省力的关键。

训练主循环：

python复制device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleCNN().to(device)

num_epochs = 10
best_acc = 0.0

for epoch in range(num_epochs):
    train_loss, train_acc = train_one_epoch(
        model, train_loader, criterion, optimizer, device)
    test_loss, test_acc = evaluate(model, test_loader, criterion, device)

    print(f"Epoch [{epoch+1}/{num_epochs}] "
          f"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f} | "
          f"Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.4f}")

    # 保存验证集上效果最好的模型
    if test_acc > best_acc:
        best_acc = test_acc
        torch.save(model.state_dict(), 'best_model.pth')

print(f"Best test accuracy: {best_acc:.4f}")

用GPU还是CPU训练？Fashion-MNIST上这个网络用CPU也能训练，但每个epoch可能要1-2分钟，10个epoch大概15-20分钟。有GPU的话每个epoch几秒钟就完成了。如果只有CPU，建议把batch size调小一点，比如32，训练速度会有所提升。

4.4 训练结果分析：准确率变化曲线透露的信息

正常情况下，训练第一个epoch后，准确率应该在80%左右，到第5个epoch能到90%左右，第10个epoch训练集准确率约95%，测试集约92%。如果测试准确率明显低于训练准确率，说明过拟合；如果两者都低，说明欠拟合或训练有问题。

这里分享一个实际的训练记录：

测试准确率始终略高于或接近训练准确率，说明模型没有过拟合，训练过程健康。到第10个epoch时还有上升趋势，可以继续训练或用学习率衰减策略让loss降得更低。

5. 训练时最常踩的四个坑及排查思路

5.1 坑一：loss不降反升，或者直接变成NaN

这个坑几乎所有初学者都会碰到。排查思路按优先级排列：

先看学习率。学习率太大，梯度更新幅度过大，loss会剧烈震荡甚至变成NaN。解决办法是把学习率除以10，比如从1e-3降到1e-4，看loss是否稳定。

再看数据预处理。如果输入图片没有归一化，像素值在0-255范围内，网络前几层的输出会非常大，反向传播时梯度也可能爆炸。检查数据加载部分的Normalize是否正确。

最后看标签。Fashion-MNIST的标签是0-9的整数，CrossEntropyLoss接受这种格式，不需要做one-hot编码。如果之前用过别的框架习惯one-hot，拿过来直接用会报shape错误的提示，但如果手动做了one-hot反而会出错。

5.2 坑二：训练集准确率很高，测试集准确率上不去

这就是典型的过拟合。对当前简单的四层CNN，参数量并不算多，过拟合没到很严重的地步，但如果epoch训练得太多（比如50个以上），还是会出现。

应对过拟合有几种手段：

• Early Stopping：观察测试准确率，连续几个epoch没有提升时停止训练。
• 数据增强：对图片做随机旋转、裁剪、翻转。Fashion-MNIST的图片翻转问题要慎重处理，比如鞋子左右翻转后类别还是鞋子，但有些物品翻转后可能就不合常理了。对简单入门任务可以不做增强。
• 加正则化：在优化器里设置weight_decay，相当于L2正则化。Adam优化器下weight_decay一般用1e-4到1e-5。
• Dropout：在全连接层前加Dropout层，随机丢弃一部分神经元，打断神经元之间的共适应关系。

比如修改模型，在全连接层前加Dropout：

python复制self.dropout = nn.Dropout(0.5)

def forward(self, x):
    # ... 前面的卷积层部分不变 ...
    x = x.contiguous().view(x.size(0), -1)
    x = self.dropout(x)   # 只在训练时起作用
    x = self.fc(x)
    return x

Dropout有个特点：model.train()模式下才生效，model.eval()模式下自动关闭。这就是为什么前面强调必须正确切换训练和评估模式。

5.3 坑三：模型输出shape与实际数据不匹配

报了“Expected input batch_size to match target”或者“mat1 and mat2 shapes cannot be multiplied”这类错误，基本都是展平后维度算错了。最直接的办法是在forward里加一行打印：

python复制def forward(self, x):
    x = self.pool(F.relu(self.conv1(x)))
    x = self.pool(F.relu(self.conv2(x)))
    x = F.relu(self.conv3(x))
    x = F.relu(self.conv4(x))
    print(f"卷积后输出形状: {x.shape}")
    x = x.contiguous().view(x.size(0), -1)
    print(f"展平后形状: {x.shape}")
    x = self.fc(x)
    return x

跑一次测试代码，看看实际输出的形状是多少，然后回头去改全连接层的in_features。确认没问题后把打印去掉。

5.4 坑四：训练速度慢，每步都在等待数据

Fashion-MNIST虽然不大，但如果DataLoader的num_workers设置为0，数据加载会在主线程中进行，GPU会频繁等待数据，导致训练速度明显变慢。建议num_workers设成大于0的数字，比如2或4，让数据在子进程中进行预处理和加载。

如果是在Windows上跑，num_workers大于0时要把训练代码放到if name == 'main':下面，否则会报多进程相关的错误。这个坑和深度学习本身无关，纯粹是操作系统实现差异，但遇到过的人都知道有多闹心。

6. 简单网络不是终点：向现代卷积结构延伸的三个方向

四层卷积加一层全连接的网络虽然简单，但它能帮我们理解一个关键的判断：什么时候该在基础网络结构上做修改。这里我想分享三个与现网环境密切相关的延伸方向，也是最近几年卷积网络领域用得最多的技术。

6.1 深度可分离卷积：减少参数量的经典方案

深度可分离卷积（Depthwise Separable Convolution）把标准卷积拆成两步：深度卷积（Depthwise Convolution）和逐点卷积（Pointwise Convolution）。深度卷积在每个输入通道上单独做一个空间卷积，逐点卷积用1×1卷积混合通道信息。

以一个64通道、3×3卷积核为例：标准卷积的参数量是64×64×3×3=36864。深度可分离卷积的参数量是64×3×3（深度卷积部分）+64×64×1×1（逐点卷积部分）=576+4096=4672。参数量大约只有原来的八分之一。MobileNet系列就是基于这个思想，能在移动端或嵌入式设备上实时运行。

如果你理解了深度可分离卷积，再看当前很多热门轻量化模型，会发现它们都是在“怎样用更少的参数和计算量保留足够的表达能力”这条路线上做文章。这个思路从简单卷积网络开始就埋下了伏笔。

6.2 空洞卷积：不增加参数却扩大感受野

空洞卷积（Dilated Convolution）的核心思路是在卷积核元素之间插入空洞，从而在不增大卷积核尺寸的情况下扩大感受野。比如3×3的卷积核，rate为2时，实际感受野变成了5×5，但参数量和计算量不变。

这个技术对需要高分辨率输出的任务特别有价值。以图像分割为例，如果用普通卷积加池化来扩大感受野，特征图分辨率会降低，而分割任务需要逐像素输出，低分辨率意味着细节损失。空洞卷积可以直接在高分辨率特征图上扩大感受野，这也是DeepLab系列分割模型的基石。

反过头来看简单卷积网络里的池化操作，你会发现一个有意思的对比：池化通过降低分辨率来扩大感受野，空洞卷积则保持分辨率不变。两种方案各有利弊，理解了这一点，你在实际任务中就知道该怎么选了。

6.3 稀疏卷积与点云处理

稀疏卷积在热词里出现了多次。它和普通卷积的区别在于：普通卷积会覆盖整个输入区域，稀疏卷积只在有数据的位置做卷积运算，其余位置直接跳过。这个技术在3D点云数据处理里非常常用，因为LiDAR点云是稀疏的，90%以上的区域是空的，用普通三维卷积计算量巨大且大部分计算都是无用功。

如果你以后要接触3D视觉，稀疏卷积是绕不开的。但它的理解前提依然是标准卷积——理解了标准卷积如何处理密集的规则网格数据，才能理解稀疏卷积如何在非规则数据上设计可学习的运算模式。所以学好这篇的基础网络，绝对不是白费功夫。

6.4 从分类网络到更复杂的任务

最后说一个容易被忽略的点：我们搭的简单卷积网络做的是图像分类，但卷积层的特征提取能力是通用的。只要把最后的全连接层替换成对应的输出头，同一个特征提取器就能用于目标检测、语义分割、姿态估计等任务。

这也是为什么很多项目会先把图片送进预训练好的CNN（比如ResNet）取特征，再根据自己的任务设计后续的网络结构。理解了简单卷积网络的完整流程，你就能看懂这些“特征提取器 + 任务头”的架构设计思路，而不只是会调用一行现成的接口。

我自己在实际项目里的体会是：简单卷积网络最大的价值不是拿来做生产模型，而是用来验证想法。数据集适不适合用卷积处理、任务难不难、训练流程有没有问题，先在简单网络上跑通，再切换到更复杂的网络结构，这个工作流能为后续的模型迭代节省大量时间。

结语：动手跑通一次，比看十篇教程都管用

这篇写到这里，核心内容已经全部覆盖。最后分享一个我自己的操作习惯：每学一个新的网络结构，我一定会在两个数据集上手动跑一遍——一个简单的（Fashion-MNIST或CIFAR-10）和一个自己业务场景的数据集。简单数据集用来验证结构理解是否正确，业务数据集用来验证结构迁移是否有效。这个过程不需要写多复杂的代码，但能逼迫你搞清楚每一层输入输出的形状、每类任务需要什么样的输出头、训练配置该怎么调。

如果你正在学卷积网络，建议把上面那段代码完整敲一遍，跑一次完整的训练和评估流程，然后把网络层数改成两层或五层，看看准确率和训练速度有什么变化。这种实验做上两三次，你对卷积网络的直觉会比读二十篇文章都深刻。