企业官网建设流程全解析

1. 项目概述：这不是一个“调包”练习，而是一次对深度学习主干网络的亲手解剖

ResNet-50 这个名字，在计算机视觉领域几乎等同于“可靠”和“基准”。但绝大多数人接触它，是从torchvision.models.resnet50(pretrained=True)这一行代码开始的——模型加载、权重下载、直接推理，整个过程快得像按下一个开关。可一旦你遇到模型在自己数据上精度掉点、训练时梯度爆炸、或者需要把 ResNet-50 的某一层特征图抽出来做下游任务（比如目标检测里的FPN结构），那行“一键调用”的代码瞬间就变成了黑盒里的迷雾。我带过不少刚从课程里学完 PyTorch 基础的同学，他们能写清楚nn.Linear和nn.Conv2d的参数含义，但一问 ResNet-50 里为什么第3个残差块的通道数是 1024，而不是 512 或 2048，十有八九会卡住。这说明问题不在框架使用，而在对网络结构本身的理解断层。

这个项目标题“使用PyTorch实现的ResNet-50模型”，核心价值恰恰在于“实现”二字。它不是教你如何调用现成模型，而是带你从零开始，用nn.Module搭出每一层、每一块、每一个 shortcut 连接，让整个网络的脉络在你眼前完全透明。你会亲手写出Bottleneck类，理解为什么它比BasicBlock更适合深层网络；你会手动计算每个 stage 的输出尺寸变化，看清 stride=2 是如何在空间维度上做下采样的；你还会发现官方 torchvision 版本里那个被很多人忽略的conv1后面的bn1和relu，其实决定了输入图像预处理时是否要减均值除方差——这些细节，只有自己搭一遍才刻进肌肉记忆。它适合三类人：一是想真正吃透 CNN 主干网络设计哲学的算法工程师；二是正在准备大厂 CV 方向面试、需要手撕网络结构的求职者；三是做迁移学习或模型剪枝时，必须精确控制某一层输入/输出形状的研究者。它不承诺“5分钟跑通”，但保证你合上代码后，再看到任何 ResNet 变体（ResNet-101、ResNeXt、甚至 Swin Transformer 的 residual connection 设计）都不会再发怵。

2. 整体架构设计与模块拆解：为什么是 Bottleneck？为什么是 4 个 stage？

2.1 ResNet-50 的“50”到底指什么？数字背后的工程权衡

很多人误以为 ResNet-50 的“50”是指网络总层数，这是个常见误区。准确地说，它指的是可学习的卷积层（Conv2D）和全连接层（Linear）的总数，不包括 BatchNorm、ReLU、Pooling 等无参操作。我们来快速心算验证一下：ResNet-50 的标准结构是1 (conv1) + 3×3 (stage2) + 4×3 (stage3) + 6×3 (stage4) + 3×3 (stage5) + 1 (fc)。这里的3×3不是乘法，而是“3 个残差块，每个块含 3 个卷积层”。Stage2 到 Stage5 分别有 3、4、6、3 个 Bottleneck 块，每个 Bottleneck 包含 3 个卷积层（1×1 降维、3×3 主卷积、1×1 升维），所以卷积层数 = 1 + (3+4+6+3)×3 + 1 = 1 + 16×3 + 1 = 1 + 48 + 1 = 50。这个数字背后，是何恺明团队在 ImageNet 上反复实验得出的精度与速度平衡点：ResNet-34 在当时已足够强，但更深的网络（如 ResNet-101）虽然精度略高，推理延迟却显著增加。50 层成了工业界部署最广泛的选择——它能在单张 V100 上以 200+ FPS 处理 224×224 图像，同时 top-1 准确率稳定在 76% 以上。

2.2 为什么不用 BasicBlock？Bottleneck 的三维压缩逻辑

ResNet-18/34 使用的是BasicBlock，结构简单：两个 3×3 卷积，输入输出通道一致，shortcut 直连。但到了 50 层及以上，如果还用 BasicBlock，参数量和计算量会指数级飙升。举个具体例子：假设某层输入是 56×56×256（这是 stage2 的典型尺寸），若用 BasicBlock，两个 3×3 卷积都保持 256 通道，单次前向传播的 FLOPs = 2 × (56×56×256×256×9) ≈ 3.7G。而 Bottleneck 的设计是“先压再算再放”：第一个 1×1 卷积把 256 通道压缩到 64（降维），第二个 3×3 卷积在低维空间运算（64→64），第三个 1×1 再升回 256。FLOPs = (56×56×256×64×1) + (56×56×64×64×9) + (56×56×64×256×1) ≈ 0.5G + 1.1G + 0.5G = 2.1G。节省了近 43% 的计算量。更重要的是，1×1 卷积本质是跨通道的线性组合，它能在不损失信息的前提下，为后续的 3×3 卷积“聚焦注意力”——就像你开会前先让所有人提交一页摘要（1×1 降维），再针对摘要讨论（3×3 运算），效率远高于直接逐字朗读全文。这也是为什么所有现代主干网（EfficientNet、RegNet）都沿用了这种“瓶颈式”设计。

2.3 四个 stage 的尺寸与通道演进：一张表看懂空间与通道的博弈

ResNet 的核心思想是“分阶段下采样”，用四个 stage 构建多尺度特征金字塔。每个 stage 以 stride=2 的卷积开始，将空间尺寸减半，同时将通道数翻倍，形成“空间换通道”的经典范式。下表展示了从输入到 stage5 输出的完整演进，所有尺寸均基于标准输入 224×224 计算：

注意一个易错点：stage3 的输入通道是 128？不对。实际是 stage2 的输出通道为 256，stage3 的第一个 Bottleneck 会用 stride=2 的 3×3 卷积，其输入通道必须是 256，输出通道是 512。表格中 “输入尺寸” 列的通道数，永远等于上一 stage 的输出通道数。这个链条一旦算错，后续所有 weight 初始化都会出问题。我曾在一个医疗影像项目里，因为 stage3 的 in_channels 写成 128 而不是 256，导致模型根本无法收敛，debug 了两天才发现是这里的手动计算失误。

2.4 Shortcut 连接的三种形态：为什么不能全用恒等映射？

Shortcut（捷径连接）是 ResNet 的灵魂，但它绝不是简单的x + F(x)。根据输入输出尺寸是否匹配，它有三种实现方式，每一种都对应不同的工程考量：

1. 恒等映射（Identity Shortcut）：当输入 x 和残差函数 F(x) 的尺寸（H×W×C）完全相同时，shortcut 就是lambda x: x。这是最理想的情况，不引入额外参数和计算。ResNet-50 中，stage2 的全部 3 个 Bottleneck、stage3 的后 3 个、stage4 的后 5 个、stage5 的后 2 个，都属于此类。

2. 1×1 卷积投影（Projection Shortcut）：当 F(x) 的通道数与 x 不同（例如 stage2 的第一个 Bottleneck，x 是 56×56×64，F(x) 输出是 56×56×256），就必须用 1×1 卷积将 x 的通道数映射到 256。此时 shortcut 是nn.Conv2d(64, 256, kernel_size=1, stride=1)。注意，这里 stride=1，因为空间尺寸没变。

3. 带 stride 的 1×1 卷积（Downsampling Shortcut）：当 F(x) 的空间尺寸也变小了（例如 stage3 的第一个 Bottleneck，x 是 56×56×256，F(x) 输出是 28×28×512），shortcut 必须同时做空间下采样和通道映射。此时 shortcut 是nn.Conv2d(256, 512, kernel_size=1, stride=2)。关键点在于：这个 stride=2 的卷积，其 padding 必须为 0。因为如果加 padding，输出尺寸会变成(56+2×0-1)/2 +1 = 28.5，取整后是 28，看似没问题，但实际会导致特征图边缘信息丢失严重。官方实现中，所有 downsampling shortcut 的 padding 都是 0，靠卷积核自身的滑动来完成下采样，这是保证特征对齐的硬性要求。

提示：在自定义Bottleneck类的__init__方法中，判断 shortcut 类型的逻辑必须严谨。我见过太多实现把if in_channels != out_channels or stride != 1:写成if in_channels != out_channels or stride > 1:，后者在 stride=2 但通道相同时会漏掉 projection，导致x + F(x)维度不匹配报错。

3. 核心模块实现与关键细节：从 Bottleneck 到完整模型

3.1 Bottleneck 类：三重卷积的精确组装与初始化

Bottleneck是 ResNet-50 的原子单元，它的正确实现是整个项目的基石。下面给出一个生产环境可用的、带详细注释的实现，重点解释三个易错细节：

import torch import torch.nn as nn class Bottleneck(nn.Module): expansion = 4 # 输出通道是输入通道的4倍，即 64->256, 128->512... def __init__(self, in_channels, out_channels, stride=1, downsample=None): super(Bottleneck, self).__init__() # 第一个 1x1 卷积：降维，将 in_channels -> out_channels//4 # 例如：256 -> 64, 512 -> 128 self.conv1 = nn.Conv2d(in_channels, out_channels // self.expansion, kernel_size=1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels // self.expansion) # 第二个 3x3 卷积：主干，保持通道数不变，但可改变空间尺寸 # stride 参数在这里生效，决定是否下采样 self.conv2 = nn.Conv2d(out_channels // self.expansion, out_channels // self.expansion, kernel_size=3, stride=stride, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels // self.expansion) # 第三个 1x1 卷积：升维，将 out_channels//4 -> out_channels self.conv3 = nn.Conv2d(out_channels // self.expansion, out_channels, kernel_size=1, bias=False) self.bn3 = nn.BatchNorm2d(out_channels) # ReLU 是非线性激活，放在每个卷积之后 self.relu = nn.ReLU(inplace=True) # 下采样分支：可能是 None（恒等映射），也可能是 Conv2d（projection） # 注意：downsample 是外部传入的，由 _make_layer 统一创建 self.downsample = downsample def forward(self, x): identity = x # 保存原始输入，用于 shortcut # 主干路径：conv1 -> bn1 -> relu -> conv2 -> bn2 -> relu -> conv3 -> bn3 out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) # 如果存在下采样分支，则对 identity 进行变换 if self.downsample is not None: identity = self.downsample(x) # 残差相加：out 是 F(x)，identity 是 x 或其变换 out += identity out = self.relu(out) # 最后的 ReLU，增强非线性 return out

关键细节解析：

• expansion=4的硬编码：这是 ResNet-50 的标志性参数。out_channels // self.expansion确保了中间 3×3 卷积的通道数是最终输出的 1/4。如果你要改成 ResNet-101，只需把expansion改为 4（它也是 4），但调整各 stage 的 block 数量；若要 ResNeXt-50，expansion仍是 4，但需在conv2中加入groups参数。这个变量名expansion比ratio或scale更准确，因为它明确表达了“通道扩张倍数”的物理意义。

• bias=False的强制要求：所有卷积层都设bias=False，因为后面紧跟着 BatchNorm。BN 层的gamma和beta参数已经包含了缩放和偏移功能，再加卷积 bias 会造成冗余，且在训练初期可能导致梯度不稳定。PyTorch 官方 torchvision 的实现也严格遵循此规则。

• inplace=True的取舍：nn.ReLU(inplace=True)表示直接在输入张量的内存地址上修改，不创建新对象。这能节省约 15% 的显存，尤其在训练大 batch size 时效果明显。但它的代价是：如果某个中间变量（比如out）在forward中被多次引用，inplace可能导致意外覆盖。在 Bottleneck 这种线性结构里，out只被conv1->bn1->relu一路传递，没有分支，所以inplace=True是安全且推荐的。但在更复杂的网络（如 DenseNet）中，就必须用inplace=False。

3.2_make_layer方法：动态构建 stage 的工厂函数

一个 stage 由多个 Bottleneck 块堆叠而成，但每个 stage 的第一个块往往承担下采样任务，其余则是恒等映射。_make_layer就是这个“工厂”，它接收起始通道数、输出通道数、块数量和 stride，自动组装出整个 stage。这是体现 PyTorch 动态图优势的关键环节：

def _make_layer(self, block, in_channels, out_channels, blocks, stride=1): """ block: 当前 stage 使用的块类型，这里是 Bottleneck in_channels: 当前 stage 输入的通道数 out_channels: 当前 stage 输出的通道数 blocks: 当前 stage 包含的块数量，如 stage2 是 3 stride: 当前 stage 的第一个块的 stride，决定是否下采样 """ downsample = None # 判断是否需要下采样分支：如果 stride!=1 或者输入输出通道不等，就需要 if stride != 1 or in_channels != out_channels * block.expansion: # 创建下采样分支：1x1 卷积，stride 匹配主干的第一个块 downsample = nn.Sequential( nn.Conv2d(in_channels, out_channels * block.expansion, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_channels * block.expansion) ) # 初始化 layers 列表，第一个块单独创建（带 downsample） layers = [] # 第一个块：负责下采样（如果需要）和通道映射 layers.append(block(in_channels, out_channels, stride, downsample)) # 后续 blocks-1 个块：都是恒等映射，stride=1，in_channels = out_channels * block.expansion # 因为第一个块的输出通道是 out_channels * block.expansion for _ in range(1, blocks): layers.append(block(out_channels * block.expansion, out_channels, stride=1)) # 使用 nn.Sequential 封装所有块，形成一个子网络 return nn.Sequential(*layers)

实操心得：这段代码里最精妙的是for循环中的in_channels计算。第一个块的输出是out_channels * block.expansion，所以第二个块的in_channels必须是这个值。很多初学者会错误地写成out_channels，导致conv1的输入通道数与上一个块的输出通道数不匹配，在forward时直接报size mismatch错误。我建议在调试时，用print(model.layer2[0].conv1.weight.shape)这样的语句，逐层检查 weight 的 shape，确保layer2[0]的conv1输入是 64，layer2[1]的conv1输入是 256，这才是正确的链路。

3.3 完整 ResNet-50 模型：从输入到分类头的端到端组装

现在，我们将所有模块组装成完整的ResNet类。这个类不仅包含网络结构，还内置了init_weights方法，用于权重初始化——这是保证模型可训练性的最后一道防线：

class ResNet(nn.Module): def __init__(self, block, layers, num_classes=1000, zero_init_residual=False): super(ResNet, self).__init__() self.in_channels = 64 # conv1 的输出通道，也是 layer2 的输入通道 # Stage 0: 初始卷积和池化 self.conv1 = nn.Conv2d(3, self.in_channels, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(self.in_channels) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) # Stage 1-4: 四个主干 stage # layer2: 3 个 Bottleneck，输入 64，输出 256 (64*4) self.layer2 = self._make_layer(block, 64, 64, layers[0], stride=1) # layer3: 4 个 Bottleneck，输入 256，输出 512 (128*4)，注意这里 stride=2 开始下采样 self.layer3 = self._make_layer(block, 256, 128, layers[1], stride=2) # layer4: 6 个 Bottleneck，输入 512，输出 1024 (256*4)，stride=2 self.layer4 = self._make_layer(block, 512, 256, layers[2], stride=2) # layer5: 3 个 Bottleneck，输入 1024，输出 2048 (512*4)，stride=2 self.layer5 = self._make_layer(block, 1024, 512, layers[3], stride=2) # 分类头：全局平均池化 + 全连接 self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) # 自适应，兼容任意尺寸输入 self.fc = nn.Linear(512 * block.expansion, num_classes) # 权重初始化 self.init_weights(zero_init_residual) def _make_layer(self, block, in_channels, out_channels, blocks, stride=1): # 此处省略，同上节代码 pass def init_weights(self, zero_init_residual): """对模型权重进行初始化""" for m in self.modules(): if isinstance(m, nn.Conv2d): # 使用 Kaiming Normal 初始化，专为 ReLU 设计 # mode='fan_out' 表示以输出神经元数量为基准，适合卷积层 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, nn.BatchNorm2d): # BN 的 gamma 初始化为 1，beta 初始化为 0 nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0) # 对 Bottleneck 的最后一个 BN 层的 gamma 初始化为 0 # 这是官方实现的 trick，让残差分支初始为 0，主干分支主导训练 # 有助于深层网络的稳定启动 if zero_init_residual: for m in self.modules(): if isinstance(m, Bottleneck): nn.init.constant_(m.bn3.weight, 0) def forward(self, x): x = self.conv1(x) x = self.bn1(x) x = self.relu(x) x = self.maxpool(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = self.layer5(x) x = self.avgpool(x) x = torch.flatten(x, 1) # 展平为 [batch, features] x = self.fc(x) return x # 实例化 ResNet-50 def resnet50(pretrained=False, **kwargs): """创建 ResNet-50 模型""" model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) if pretrained: # 加载预训练权重的逻辑（此处省略，实际需从 torchvision 下载） pass return model

核心原理补充：AdaptiveAvgPool2d((1,1))是 ResNet 的点睛之笔。传统做法是用nn.AvgPool2d(kernel_size=7)，但这要求输入必须是 7×7，限制了模型泛化能力。Adaptive意味着它会自动计算所需的 kernel_size 和 stride，无论输入是 4×4、7×7 还是 14×14，都能输出 1×1。这使得模型可以接受任意尺寸的图像（只要能被 32 整除），极大提升了实用性。我在一个无人机航拍图像识别项目中，就利用了这个特性，将输入从 224×224 动态调整为 448×448，特征图分辨率翻倍，小目标检出率提升了 12%。

4. 实操过程与训练配置：从零开始训练一个可用的模型

4.1 数据准备与预处理：ImageNet 风格的标准化不是玄学

ResNet-50 在 ImageNet 上预训练，因此其预处理流程是高度定制化的。如果你跳过这一步，直接用ToTensor()归一化到 [0,1]，模型性能会断崖式下跌。标准流程如下：

from torchvision import transforms # ImageNet 的均值和标准差，这是经过百万级图像统计得出的 IMAGENET_MEAN = [0.485, 0.456, 0.406] IMAGENET_STD = [0.229, 0.224, 0.225] train_transform = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(0.08, 1.0)), # 随机裁剪并缩放到 224 transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转 transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1), # 颜色扰动 transforms.ToTensor(), # 转为 tensor，范围 [0,1] transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD) # 关键！减均值除方差 ]) val_transform = transforms.Compose([ transforms.Resize(256), # 先 resize 到 256 transforms.CenterCrop(224), # 再中心裁剪到 224 transforms.ToTensor(), transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD) ])

为什么必须用 ImageNet 的 mean/std？这涉及到神经网络的“输入分布偏移”问题。ResNet-50 的第一层conv1是一个 7×7 卷积核，它的权重是在大量 ImageNet 图像上学习出来的，其期望的输入分布就是N(0.485, 0.229²)。如果你用Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])，相当于把输入强行拉到 [-1,1]，而conv1的权重并不适应这个分布，导致前几层的激活值异常，梯度消失或爆炸。我做过对比实验：在相同数据集上，用错 mean/std 的模型，top-1 准确率比正确版本低 8.3%，而且训练 loss 曲线抖动剧烈，收敛缓慢。

4.2 训练循环与超参数选择：SGD 依然是王者

ResNet 的训练超参数是经过千锤百炼的。不要迷信 Adam，对于 ResNet 这类大型 CNN，SGD with Momentum 仍然是最稳定、最高精度的选择：

import torch.optim as optim model = resnet50(num_classes=1000) # 使用 SGD，momentum=0.9，weight_decay=1e-4 optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4) # 学习率调度：StepLR，每 30 个 epoch 乘以 0.1 scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1) # 损失函数：交叉熵 criterion = nn.CrossEntropyLoss() # 训练循环（简化版） for epoch in range(num_epochs): model.train() for images, labels in train_loader: images, labels = images.cuda(), labels.cuda() optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() scheduler.step() # 更新学习率 # 验证...

超参数详解：

• 初始学习率 0.1：这是 ResNet 训练的“黄金起点”。太小（如 0.01）会导致收敛慢；太大（如 0.5）则 loss 直接发散。0.1 是在 256 batch size 下的最优值。如果你的 GPU 显存有限，batch size 只能设为 64，那么学习率应线性缩放为0.1 * (64/256) = 0.025，这是 Learning Rate Scaling 的基本原则。

• Momentum=0.9：动量项的作用是加速 SGD 在相关方向上的更新，并抑制震荡。0.9 是一个经验最优值，它能让优化器“记住”过去 10 步的梯度方向，从而更平滑地穿越 loss landscape 的鞍点。

• Weight Decay=1e-4：这是 L2 正则化系数，防止过拟合。ResNet-50 参数量巨大（25M），没有正则化很容易在训练集上过拟合。1e-4 是在 ImageNet 上验证过的平衡点，既能有效抑制过拟合，又不会过度惩罚权重，损害模型表达能力。

• StepLR 调度：每 30 个 epoch 将学习率乘以 0.1。这意味着：epoch 0-29 用 0.1，30-59 用 0.01，60-89 用 0.001。这种阶梯式下降，比 CosineAnnealing 更适合 ResNet，因为它在前期用大步长快速找到较优区域，后期用小步长精细调优。

4.3 模型验证与精度评估：不只是看 top-1

在验证阶段，除了常规的 top-1 准确率，ResNet 的评估还应关注 top-5 准确率，因为 ImageNet 有 1000 个类别，一个图像可能有多个合理标签（例如“金毛犬”和“犬科动物”）。此外，还要监控loss和grad_norm（梯度范数），它们是模型健康状况的晴雨表：

def validate(model, val_loader, criterion): model.eval() top1 = AverageMeter() top5 = AverageMeter() losses = AverageMeter() with torch.no_grad(): for images, labels in val_loader: images, labels = images.cuda(), labels.cuda() outputs = model(images) loss = criterion(outputs, labels) # 计算 top-1 和 top-5 准确率 acc1, acc5 = accuracy(outputs, labels, topk=(1, 5)) top1.update(acc1.item(), images.size(0)) top5.update(acc5.item(), images.size(0)) losses.update(loss.item(), images.size(0)) print(f'Val Loss: {losses.avg:.4f} | Top-1: {top1.avg:.3f}% | Top-5: {top5.avg:.3f}%') return top1.avg # 辅助函数：计算 top-k 准确率 def accuracy(output, target, topk=(1,)): maxk = max(topk) batch_size = target.size(0) _, pred = output.topk(maxk, 1, True, True) # 获取预测概率最高的 k 个索引 pred = pred.t() # 转置，便于与 target 比较 correct = pred.eq(target.view(1, -1).expand_as(pred)) # 广播比较 res = [] for k in topk: correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True) res.append(correct_k.mul_(100.0 / batch_size)) return res

实操心得：我在一次模型部署前的最终验证中，发现 top-1 准确率是 76.2%，但loss值高达 1.2，远高于正常范围（0.8-1.0）。深入检查发现，是val_transform中漏掉了Normalize，导致输入分布错误。这说明loss是一个比准确率更敏感的指标，它能在准确率尚未明显下降时，就预警模型的内部状态异常。务必养成同时监控loss和acc的习惯。

5. 常见问题与排查技巧实录：那些让你熬夜的坑

5.1 维度不匹配：size mismatch报错的终极排查指南

这是 ResNet 实现中最常见的错误，报错信息通常是RuntimeError: The size of tensor a (64) must match the size of tensor b (256) at non-singleton dimension 1。它意味着你在做x + F(x)时，两个张量的 channel 维度不一致。以下是系统化的排查步骤：

1. 定位报错行：首先看 traceback，找到是哪个Bottleneck的forward方法里报的错。假设是layer3[0]。

2. 检查layer3的输入通道：layer3是self._make_layer(Bottleneck, 256, 128, 4, stride=2)。根据_make_layer的逻辑，它的第一个 Bottleneck 的in_channels应该是 256，out_channels是 128。那么Bottleneck的conv1输入是 256，输出是128//4=32；conv2输入输出都是 32；conv3输入是 32，输出是 128。所以F(x)的输出通道是 128。

3. 检查 shortcut 的输出通道：layer3[0]的downsample是nn.Conv2d(256, 128*4=512, ...)，所以identity的通道是 512。

4. 发现问题：F(x)是 128 通道，