写这个系列的时候，我发现很多零基础的朋友学到"神经网络的卷积层和池化层"这一块，最容易卡壳。不是公式看不懂，而是不知道这两层到底在干嘛、参数为什么这样设、搭好的网络为什么报错。我当年也是从一脸懵过来的，比如第一次见到nn.Conv2d的in_channels和out_channels时，完全想不明白它俩和图片的"通道"是什么关系，更不用说后面还有stride、padding、kernel_size这一堆参数等着折磨人。所以这一篇，我不打算堆理论，而是用"一个图像分类任务"串起整个流程，把卷积层和池化层的前因后果、参数细节、尺寸计算、实战代码和踩坑经验一次性讲清楚。这篇内容适合刚学完PyTorch基础张量操作、准备进入神经网络实战的读者，也适合那些已经把网络跑通但始终没搞懂内部原理的朋友。
1. 为什么全连接层遇到图像就"白给"——卷积层的设计逻辑
1.1 一张小图就能把全连接网络撑爆
先看一个最简单的例子。假设输入是一张 32x32 的彩色图片，也就是形状为[3, 32, 32]的张量——3 个颜色通道在前，宽高在后。如果第一层就用全连接层（nn.Linear），第一步就得把这 3x32x32 = 3072 个像素展开成一维向量。这还只是一张 32x32 的小图，如果连接到隐藏层 1024 个神经元，这层的权重矩阵就是 3072x1024，光这一层就有大概 314 万个参数。想想看，在 MNIST 这种 28x28 灰度图都算"大输入"的年代，全连接层勉强能接受；但放到真实场景里，一张 256x256 的彩色图片展开就是 196608 维，全连接层直接失去意义。
参数量大还不是最致命的问题。全连接网络还有一个隐藏缺陷：它在处理像素时是"一视同仁"的，完全不管像素之间的空间关系。一张猫的图片，把像素打乱重排之后，在全连接网络看来可能和原图"差不多"——因为每个位置都是独立权重，空间的相对位置信息被完全丢掉了。这显然不是我们想要的。
1.2 卷积层的三个关键设计思路
卷积层解决这个问题，靠的是三个朴素但极其有效的思路：
局部感受野。人看一张图，不会先看完整张图再去判断里面的物体。先看局部细节——眼睛、耳朵、胡须——再把局部信息整合起来。卷积层就是这个套路：每次只用一个很小的窗口（比如 3x3）去扫过图像，每次只看窗口覆盖的那一小块区域，识别局部特征。这个窗口就是kernel_size。
权值共享。一个卷积核的权重在整个图像上是"摊开用"的。打个比方：全连接层相当于给每个像素请一个专职保安，每个人只守自己的位置；卷积层相当于一支巡逻队，同一支队伍在整张图上巡逻，不管走到哪里都用同一套判断标准。这个设计让参数量瞬间降下来。一个 3x3 卷积核只有 9 个权重参数（再加上 1 个偏置），哪怕输入是几千乘几千的大图，参数也不增加。
平移不变性。猫出现在图片左上角和右下角，本质上是同一只猫。卷积核在整个图上滑动，同一个特征不管出现在什么位置都能被捕捉到。这就是平移不变性，也是卷积网络在处理图像时比全连接网络天然更合理的原因。
所以卷积层的本质可以这样理解：每个卷积核就是一个小型特征提取器。第一层学到的往往是边缘、颜色块这类低级特征；深层卷积核慢慢组合出纹理、形状、甚至物体的部件。这也是为什么常说卷积神经网络有"从低级到高级"的特征提取过程。
1.3 PyTorch里它长什么样
在 PyTorch 中，二维卷积就是torch.nn.Conv2d。它接收的输入形状是[batch_size, in_channels, height, width]，输出的形状是[batch_size, out_channels, new_height, new_width]。还是那句话：通道在前，宽高在后，这和很多其他框架的习惯不一样，刚接触 PyTorch 的人经常栽在这里。
import torch import torch.nn as nn # 输入模拟：4张 3通道 32x32 的图片 x = torch.randn(4, 3, 32, 32) # 卷积层：输入3通道，输出16通道，卷积核3x3 conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3) # 前向计算 y = conv(x) print("输入形状:", x.shape) # torch.Size([4, 3, 32, 32]) print("输出形状:", y.shape) # torch.Size([4, 16, 30, 30])注意输出尺寸：3x3 卷积核，步长为默认的stride=1，没有 padding，32x32 的图会变成 30x30。为什么少了 2？这个细节后面专门讲尺寸计算的时候说清楚。
2. 手把手拆解Conv2d的六个关键参数
这一节把nn.Conv2d最常用的参数逐个过一遍。我不会照着文档念，只讲每个参数在实际训练中的影响，以及怎么设置最不容易出问题。
2.1 in_channels 和 out_channels
in_channels是输入数据的通道数，这个必须和输入张量对上。灰度图是 1，RGB 彩色图是 3，如果前面接的是另一个卷积层，那就等于上一层的out_channels。
out_channels是一个容易误解的参数。它不是"输出的图片数量"，而是这一层用了多少个卷积核。每个卷积核会扫描一遍整张输入图，生成一张独立的特征图。所以输出的通道数就等于卷积核的数量：16 个卷积核就输出 16 张特征图。你可以把每张特征图理解成"从某个视角看到的图像信息"，比如有的图强调横向边缘，有的图强调圆形的轮廓。
这里有个典型的疑问：既然 RGB 图有 3 个通道，那第一个卷积层是不是必须设置in_channels=3？是的。不过要注意，一个卷积核在计算时，是同时看所有输入通道的。以in_channels=3, out_channels=16为例，这一层有 16 个卷积核，每个卷积核实际上是形状[3, kernel_height, kernel_width]的小张量，它同时扫描 R、G、B 三个通道，最后叠加出一个输出值。所以卷积层的参数总量是：
单个卷积核参数量 = in_channels * kernel_height * kernel_width + 1（偏置） 本层总参数量 = out_channels * 单个卷积核参数量3x3 卷积核、输入 3 通道、输出 16 通道时，总参数 = 16 * (3*3*3 + 1) = 448 个参数。和全连接层动辄上百万的参数比起来，可以说是非常轻量了。
2.2 kernel_size：窗口到底该设多大
kernel_size可以写成单个整数（如3，代表 3x3），也可以写成元组（如(3, 5)，代表高 3、宽 5）。实操中绝大多数情况用3或1。
- 3x3 是最常用的选择。两层 3x3 卷积堆叠，感受野能达到 5x5，但参数量比直接用 5x5 少得多。这也是很多经典网络大量使用 3x3 的原因。
- 1x1 卷积看起来像"逐像素的全连接"，但它能改变通道数，可以做通道间的信息融合，同时几乎不改变宽高。在轻量网络里很常见。
- 5x5、7x7适合网络很靠前的层、需要快速扩大感受野的场景，但参数量增长快，新手不建议上来就用大卷积核。
2.3 stride：卷积核每次挪多远
stride是卷积核在图像上滑动的步长。默认是 1，意味着卷积核每次移动 1 个像素，输出尺寸和原来差不多；如果设为 2，卷积核每次跳 2 个像素，输出尺寸大约减半。
stride 的作用除了降分辨率，更重要的是替代一部分池化功能。现在很多网络设计倾向于用 stride=2 的卷积来做下采样，而不是卷积后面跟池化层，效果往往更好。但新手阶段不要急着玩这种操作，先保持stride=1，把网络跑通再说。
conv_stride2 = nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1) y = conv_stride2(x) print(y.shape) # torch.Size([4, 16, 16, 16])上面代码从 32x32 直接变到 16x16。注意这里我加了padding=1，否则按照公式算，输出会变成(32-3)/2+1 = 15.5，PyTorch 会向下取整成 15，不对称，后面讲尺寸计算时细说。
2.4 padding：给图像"打补丁"
padding的作用是在输入图像的四周补像素，通常补 0。最核心的原因有两个：
第一，防止尺寸衰减过快。不加 padding，每过一个 3x3 卷积，宽高各减 2。层数一多，特征图缩到没法看。加了padding='same'或padding=(kernel_size-1)//2之后，卷积不改变尺寸。
第二，保护边缘信息。没有 padding 时，图像边缘像素只被卷积核覆盖过一两次，中心像素会被覆盖很多次，这导致边缘信息天然被"歧视"。padding 给了边缘像素同样的被扫描机会。
PyTorch 中padding的取值可以是整数、元组，也可以是特殊字符串'same'和'valid'。其中padding='same'会自动计算 padding 值，尽量让输出尺寸等于输入尺寸。但注意：stride 大于 1 时，'same'的"尺寸不变"效果是相对的，实际输出会约等于输入除以 stride，这符合下采样的需求。
# 两种常见的 padding 写法 conv_same = nn.Conv2d(3, 16, kernel_size=3, padding='same') # 3x3 卷积，尺寸不变 conv_manual = nn.Conv2d(3, 16, kernel_size=3, padding=1) # 与上面等价2.5 dilation：卷积核的"变焦"
dilation是膨胀系数，控制卷积核各元素之间的间隔。dilation=1 是标准 3x3；dilation=2 相当于一个 3x3 的核扩展成 5x5 的间隔，感受野变大，但参数量不变。实际项目中膨胀卷积常用在分割、检测任务里，需要扩大感受野又不增加参数的时候。新手入门阶段基本用不到，知道它是干什么的、看到代码不慌就够了。
groups参数类似"分组卷积"，会让输入通道和输出通道分组连接，可以显著减少参数量，但原理和调参难度都上了一个台阶，零基础阶段没有必要深挖，等到后面读一些轻量化网络代码时再回头研究不吃亏。
bias默认是True。几乎所有情况下保持默认即可。如果卷积层后面紧跟着 BatchNorm 层，可以把 bias 设为False，因为 BatchNorm 自带平移参数，bias 是多余的。不过这是后面的主题，现在不用管。
3. 输出尺寸计算：公式、'same'的坑和一张实测对照表
3.1 一条公式解决所有问题
卷积层和池化层的输出尺寸计算，通用公式是长这样的：
输出尺寸 = floor((输入尺寸 + 2 * padding - dilation * (kernel_size - 1) - 1) / stride + 1)如果不考虑 dilation（即 dilation=1），公式可以简化成：
输出尺寸 = floor((输入尺寸 + 2 * padding - kernel_size) / stride + 1)来验证一下刚才的例子：输入 32，kernel_size=3，padding=0，stride=1：
(32 + 0 - 3) / 1 + 1 = 30再验证带 padding 的：输入 32，kernel_size=3，padding=1，stride=1：
(32 + 2 - 3) / 1 + 1 = 32尺寸不变。这正好解释了padding=kernel_size//2之所以成为标准写法的原因。
3.2 无法整除时会发生什么
如果把上面那个 stride=2 的例子代入公式：
(32 + 2 - 3) / 2 + 1 = 15.5 + 1 = 16.5PyTorch 对小数部分采取向下取整，所以输出就是 16。这在实际使用中通常可以接受，但有一个容易被忽略的问题：如果输入尺寸是奇数，或者 padding、kernel_size 的奇偶性没配对，输出尺寸会出现不对称，后续展平到全连接层时容易算错维度。
我踩过一个典型的坑：在某次实验中输入是 31x31 的特征图，我用kernel_size=3, padding=1, stride=2卷积，输出变成了 16。下一次再卷一次，输出变成 8。表面看起来尺寸变化是"有规律的"，但如果我在某个环节想当然地认为它是 "(31-3+2)/2+1=16" 然后写死代码，等换输入尺寸时就直接崩了。
所以我的建议是：不要在代码里手算尺寸写死，要么用一个小函数自动算，要么在前向传播里用x.shape动态获取展平后的维度，后面第五节的完整代码会演示这一点。
3.3 padding='same' 的隐藏行为
PyTorch 从某个版本开始支持padding='same'，很多人以为用了它输出尺寸就一定等于输入尺寸。实际上，当stride > 1时，输出尺寸是：
输出尺寸 = ceil(输入尺寸 / stride)这依然是向下采样，只是保证尺寸能被整除时的边界行为。比如 stride=2、输入 31 时，'same'会以 padding=1 计算，输出约等于 16；输入 32 时输出 16。所以根本没毛病，但它并不能真正实现"同样尺寸"，这个意识要建立起来。
3.4 卷积与池化的实测对照
我把几个常用组合实际跑了一遍，结果贴在下面，方便大家对着检查自己的理解。输入统一用[1, 1, 32, 32]。
| 操作 | kernel | padding | stride | 理论输出尺寸 | 实际输出尺寸 |
|---|---|---|---|---|---|
| Conv2d | 3 | 0 | 1 | 30 | 30 |
| Conv2d | 3 | 1 | 1 | 32 | 32 |
| Conv2d | 3 | 1 | 2 | 16 | 16 |
| Conv2d | 5 | 2 | 1 | 32 | 32 |
| MaxPool2d | 2 | 0 | 2 | 16 | 16 |
| MaxPool2d | 3 | 1 | 1 | 32 | 32 |
写完这个表之后，我发现很多新手的困惑其实不是公式不会，而是不知道"卷积核默认中心对齐，padding 要同时补上下左右"。padding=1是在上下左右各补一圈，总共增加 2 个像素，这个"2"特别容易被记成"1 像素 = 尺寸 +1"，然后就理解错了。以后统一记住：padding 的数值是单边补多少，总尺寸变化要乘以 2。
4. 池化层：除了压缩特征图，它还在干什么
4.1 MaxPool2d 到底选了啥
池化层最常见的写法是nn.MaxPool2d(kernel_size=2, stride=2)，它对特征图做的操作是：把图片分成若干个不重叠的 2x2 小块，每个小块中只保留最大值，其余三个值丢掉。
用数字举个例子。假设输入是：
[7, 3, 2, 8] [5, 9, 1, 4]2x2 池化后会变成两个块：第一个 2x2 块取最大值 9，第二个 2x2 块取最大值 8，输出：
[9, 8]为什么要取最大值而不是平均值？直觉上最大值保留了局部区域内"最强烈的特征信号"，比如最明显的边缘、最亮的点。这本质上是给网络提供了一种"局部不变性"：图像稍微平移一两个像素，池化结果往往不变，让网络对轻微的位移、形变不那么敏感。
4.2 池化不止降维，它还做了三件事
第一，减少计算量。特征图宽高减半，通道数不变，后续层的计算量明显下降。这是最直观的作用。
第二，扩大感受野。一个 2x2 的池化层后，特征图上的每个像素代表 2x2 原图区域；连续池化几次，深层每个点已经能看到原图的很大一块区域了。这对判断"整张图里有什么"非常重要。
第三，缓解过拟合。丢掉大量细节、只保留局部最强的响应，相当于一种隐式的正则化。参数变少了，模型复杂度降低了，过拟合风险自然下降。
4.3 MaxPool vs AvgPool：不同场景的选择
nn.MaxPool2d是主流，但nn.AvgPool2d也有它的位置。最大池化对纹理、边缘这类特征比较敏感；平均池化则更平滑，适合保留整体背景信息。统计上，图像分类网络几乎都用最大池化；而有些生成类任务、或者要把特征图直接接到分类头的时候，也会用全局平均池化nn.AdaptiveAvgPool2d(1)把整张特征图压成一个值，替代 Flatten + 全连接，效果往往更稳。
# 最大池化，默认 stride=kernel_size pool = nn.MaxPool2d(kernel_size=2) x = torch.randn(2, 16, 32, 32) y = pool(x) print(y.shape) # torch.Size([2, 16, 16, 16]) # 全局平均池化：直接把每个通道压成一个值 gap = nn.AdaptiveAvgPool2d(1) z = gap(x) print(z.shape) # torch.Size([2, 16, 1, 1])注意nn.MaxPool2d(2)如果不写stride，默认stride=kernel_size，也就是 2；在实际写代码时我建议把stride也显式写出来，避免忘记默认行为导致尺寸算错。
4.4 一个越来越常见的趋势
需要提一句：近几年的新网络架构里，池化层的存在感正在下降。比如很多现代网络直接用stride=2的卷积做下采样，既降分辨率又提取特征，一步完成；还有的做法是用"全局平均池化"替代最后的全连接层。但不管新架构怎么变，理解池化层的操作逻辑，是理解所有下采样手段的基础。就算以后不用nn.MaxPool2d了，你依然需要知道"下采样到原来一半大小"意味着什么。
5. 用卷积层+池化层搭一个能跑的图像分类网络
理论聊得差不多，上实战。下面我用 PyTorch 搭建一个非常经典的小型卷积网络：两层"卷积+ReLU+池化"，最后接全连接层输出分类结果。数据集用一个 28x28 的手写数字数据集，类别数是 10。整个过程在 CPU 上也能很快跑通，适合零基础复现。
5.1 网络结构定义
import torch import torch.nn as nn class SimpleCNN(nn.Module): def __init__(self): super().__init__() # 第一段：输入1通道 -> 16通道，卷积后尺寸不变，池化减半 self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, padding=1) self.relu = nn.ReLU() self.pool = nn.MaxPool2d(kernel_size=2, stride=2) # 第二段：16通道 -> 32通道，同样保持尺寸后池化减半 self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1) # 动态计算展平维度 self.flatten = nn.Flatten() # 全连接层：32个通道，7x7尺寸（28 -> 14 -> 7） self.fc = nn.Linear(32 * 7 * 7, 10) def forward(self, x): x = self.pool(self.relu(self.conv1(x))) x = self.pool(self.relu(self.conv2(x))) x = self.flatten(x) x = self.fc(x) return x每一步的尺寸变化：
| 层 | 输入尺寸 | 输出尺寸 | 说明 |
|---|---|---|---|
| conv1（3x3, padding=1） | [B, 1, 28, 28] | [B, 16, 28, 28] | 尺寸不变 |
| relu + pool（2x2, stride=2） | [B, 16, 28, 28] | [B, 16, 14, 14] | 宽高减半 |
| conv2（3x3, padding=1） | [B, 16, 14, 14] | [B, 32, 14, 14] | 尺寸不变 |
| relu + pool（2x2, stride=2） | [B, 32, 14, 14] | [B, 32, 7, 7] | 宽高减半 |
| flatten | [B, 32, 7, 7] | [B, 3277] | 展平 |
| fc | [B, 1568] | [B, 10] | 输出10类得分 |
这里的32 * 7 * 7就是手动算好的。算不出来的时候，可以先用一个小张量试一遍，打印中间每个shape，确认无误后再把数字填进去。这也是为什么我在__init__里写死之前，总会在一个临时脚本里验一遍尺寸变化。
为了偷懒且避免写死维度，也可以改成nn.Linear(1568, 10)之前用一个nn.LazyLinear(10)，但新手还是老老实实算一次，印象最深。
5.2 训练代码
数据加载部分直接使用 PyTorch 自带的数据集接口，这里为了简洁我拆成几步展示：
import torch.nn.functional as F from torch.utils.data import DataLoader # 假设已经通过某种方式拿到了 train_loader 和 test_loader model = SimpleCNN() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) num_epochs = 5 for epoch in range(num_epochs): train_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) # 前向传播 outputs = model(images) loss = criterion(outputs, labels) # 反向传播与参数更新 optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() avg_loss = train_loss / len(train_loader) print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}") # 在测试集上评估 correct = 0 total = 0 model.eval() with torch.no_grad(): for images, labels in test_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f"Test Accuracy: {100 * correct / total:.2f}%")训练大约 5 个 epoch，在 CPU 上也就是几分钟的事，但准确率就能到 95% 以上。这就是卷积层+池化层组合的威力：模型很小，参数不多，但图像分类能力明显超过同量级的全连接网络。
5.3 ReLU 放的位置有讲究
很多人第一次写conv -> relu -> pool的时候都会怀疑：relu 放在卷积后面和池化后面有区别吗？从操作本身看，ReLU 是逐元素激活，池化是局部取最大值或平均值。两者顺序其实可以互换，结果几乎一样——因为最大值先经过 ReLU 再取，和先取最大值再 ReLU，正数的关系不会改变。但默认习惯是conv -> relu -> pool，这样做的好处是：激活之后下采样，更稳定，也更符合大多数经典网络的结构。就照着这个顺序写吧，不用纠结。
5.4 为什么最后一个全连接层没有激活函数
最后的self.fc = nn.Linear(..., 10)输出的是分数（logits），不是概率。CrossEntropyLoss内部已经包含了 softmax 的过程，所以不需要在模型最后加nn.Softmax()。这一点新手特别容易搞混。如果你只想查看"每个类别的概率"，可以等到推理阶段再用torch.softmax(outputs, dim=1)，但训练时千万别这么做——softmax 会让梯度变得非常小，训练效率明显下降。在我的实际测试中，加了F.log_softmax再配NLLLoss也能跑，但纯粹是多此一举，直接CrossEntropyLoss永远是最省心的方案。
6. 新手必踩的五个坑，以及我常用的调试三板斧
真刀真枪跑代码，永远比看教程更容易踩坑。下面这几个问题，几乎每个新手都会遇到至少一次，我逐个说清楚原因和解决办法。
6.1 报错"Expected 4-dimensional input"到底是谁的问题
nn.Conv2d需要的输入是四维张量[B, C, H, W]。如果数据加载时给出的是[B, H, W, C]，或者干脆是[B, W, H]，那就会触发这个报错。原因很简单：通道维的位置不对。
解决办法有两个：一是用转置把通道维挪到第二位，对应操作可以用tensor.permute(0, 3, 1, 2)或者tensor.transpose(1, 3)；二是从数据加载源头就配置好，比如大部分深度学习框架的图像数据集读取接口，都可以通过参数指定输出是[C, H, W]而不是[H, W, C]。
我个人的做法是尽量在数据集准备阶段就把形状纠正过来，不要在每个 batch 里去转置。这样写出来的训练循环清爽，也不容易在后续改网络时埋雷。另外有个习惯值得养成：在练手阶段每次拿到一个数据，先打印images.shape，确认通道在前之后再往下写。
6.2 只有一个数据，为什么 Conv1d 能跑但结果很奇怪
有一些零基础读者会拿一维信号当二维图片处理，然后发现Conv2d直接报错。这里要分清三个层：nn.Conv1d处理的是[B, C, L]形状的一维序列，nn.Conv2d处理的是[B, C, H, W]，nn.Conv3d处理的是[B, C, D, H, W]。新手最常犯的错误是，用Conv2d处理单通道灰度图，把输入写成了[B, H, W]，少了一个显式的通道维。
灰度图也必须有通道维：[B, 1, H, W]，其中那个1就是 in_channels。如果数据读进来是[H, W]，需要先加一个维度：x = x.unsqueeze(1)，或者x = x.unsqueeze(0)加上 batch 维再 unsqueeze 通道维，具体看上下文。
6.3 尺寸越缩越小，最后全连接层维度对不上
一个很常见的场景：定义网络时手动算了展平后的维度，比如self.fc = nn.Linear(32 * 7 * 7, 10)，但因为某个卷积层忘了设 padding，或者池化步长改了一下，实际展平后不是[B, 1568]，而是[B, 1352]之类的奇怪形状，于是nn.Linear直接报维度不匹配。这个问题几乎必然出现，因为很少有人能纯靠心算推准每一层的尺寸。
我推荐两个办法。第一个是写一个小函数，把输入丢进去，沿着forward每一步打印 shape，直到全连接层之前：
test_input = torch.randn(1, 1, 28, 28) with torch.no_grad(): x = test_input x = model.conv1(x) print(x.shape) x = model.relu(x) print(x.shape) x = model.pool(x) print(x.shape) x = model.conv2(x) print(x.shape) x = model.relu(x) print(x.shape) x = model.pool(x) print(x.shape)第二步，把打印出来的最后一个 shape 乘积直接填进nn.Linear。第二个办法是用动态展平维度，比如在 forward 里x = x.view(input_x.size(0), -1)，然后使用nn.LazyLinear(10)，让 PyTorch 自动推断输入维度。但这种偷懒方式在保存和加载模型时会遇到一点小麻烦，所以新手期还是推荐老老实实打印 shape。
6.4 模型不收敛：loss 一直卡在某个值附近
如果 loss 始终在 2.3 附近徘徊、几乎不变，说明模型在训练中学不到任何有效信息。这种问题在新手网络里的高发原因有三个：
第一，学习率太大或太小。Adam 默认lr=0.001在大多数情况下没问题，但如果你改过学习率，出现震荡或 loss 一直不降，优先把它调回 0.001 试试。
第二，输入数据没有归一化。图像像素值直接落在 0 到 255 的话，第一层卷积计算的数值会偏大，梯度也可能不稳定。建议把输入归一化到 0~1 或者 0 均值单位方差，对收敛速度帮助非常大。我记得第一次训练时忘了归一化，loss 下降到一定程度就卡死不降，归一化之后直接往下掉。
第三，最后一层激活函数加错了。有人会在网络末尾加F.log_softmax之后再用CrossEntropyLoss，这相当于算了两次对数损失，会导致 loss 不降。反过来，如果模型最后没有任何激活函数，用CrossEntropyLoss就是正确的。这一条前面已经说过，但因为它太常见，我再强调一次。
6.5 GPU 显存溢出不能只怪"显存不够"
新手用 GPU 训练时第一次看到CUDA out of memory，第一反应往往是"换大显卡"。但其实大部分情况下是代码里有张量没有及时释放。排查路径是：把 batch size 调小，比如从 64 调到 16；如果还不解决，检查是否在循环中反复创建了不必要的变量；再检查optimizer.zero_grad()是否被遗忘——如果梯度累积消耗的显存太多，也会触发 OOM。
另外有一个经常被忽略的点：在训练循环里，把model.eval()和model.train()认真区分开。推理时开着torch.no_grad()能省不少显存和计算时间。我的习惯是：训练阶段必须model.train()，测试阶段必须model.eval()，否则 BatchNorm 和 Dropout 的行为会不一致，虽然预测结果一般也能出，但准确率会受影响。
6.6 我调试时常用的三板斧
第一板斧：随渠道打印 shape。在网络 forward 关键节点临时插入print(x.shape)，确认每一步的尺寸符合预期。这个是排查维度错误最快的手段，比读报错信息更直观。
第二板斧：先过拟合一个 batch。用一个 batch 数据，把训练循环跑 100 步，如果 loss 能从 2.3 降到接近 0，说明网络本身能学习，问题多在数据或优化器；如果连一个 batch 都拟合不了，问题多半在网络结构。这个技巧我从入行用到现在，效率极高。
第三板斧：把模型参数初始化和梯度检查一起做。训练一两步之后，人为设置一个错误标签，确认 loss 数值确实变大；或者直接打印第 0 步的loss.grad是否正常。如果梯度为 0，说明网络根本没更新起来。这个方法看起来笨，但能快速区分"模型没搭对"和"训练流程有 bug"。
关于池化层和卷积层的入门，我到现在还是觉得最关键的心得是"尺寸意识"——每走一步，脑子都要清楚特征图的长宽通道怎么变。这不是天赋，而是练出来的习惯。当你开始能不依赖报错、自己推算出模型每个环节的输出形状，并且能在一张图上大概预估这个网络在哪一层学到的特征长什么样，基本就算真正踏进卷积神经网络的大门了。这篇只讲了最基础的两层，后面还有激活函数选择、BatchNorm、Dropout、残差结构这些内容等着一一拆解，而这些都是在卷积层和池化层的骨架上长出来的肉，地基打牢了，后面就顺了。
方法：无锁读取)
