第一次手动实现 Inception-ResNet 时，我的第一反应是“Google 又把 Inception 和 ResNet 拼了一桌”。真正动手把 v1 和 v2 两条网络在 PyTorch 里跑通之后，我才意识到这盘菜炒得相当讲究——它不做简单的模块拼接，而是用一堆工程细节把“多尺度特征提取”和“梯度顺畅回传”这两件原本很难兼顾的事揉在了一起。这篇笔记就是我当时逐模块推导、逐行写代码的全过程，会从设计动机讲到完整可运行的 PyTorch 实现，再补上我实测中遇到的坑和调参心得。不管你是想深入理解经典 CNN 架构，还是需要快速拿一个高精度特征提取网络做迁移学习，这篇内容都能直接派上用场。
1. 为什么要把残差连接塞进 Inception：设计动机与演进脉络
1.1 两条技术路线的碰撞
Inception 系列从一开始就在解决一个问题：同一张图里的目标尺度差异极大，固定尺寸的卷积核难以兼顾。Inception v1 的解法很直接——同一层里并行放 1x1、3x3、5x5 卷积和池化，让网络自己学到底该侧重哪个尺度。但这个方案有个致命弱点：5x5 卷积的计算量太大。于是 v2/v3 陆续补上了两个关键优化——用 1x1 卷积先降维、再用两个 3x3 替代一个 5x5，以及后面更激进的非对称分解（1x7 + 7x1 替代 7x7）。到 Inception v3 时代，Google 已经把这套“分解”哲学玩得很熟了。
ResNet 走的是另一条路。它不关心单层内部怎么组织，而是从训练动力学角度切入：网络一旦加深，梯度在反向传播时经过连乘会指数级衰减或爆炸，导致深层网络反而比浅层更难优化。残差连接通过一条“短路”让梯度可以绕过中间层直接回传，把问题变成了学习残差。换言之，Inception 一直在优化“每一层怎么提取特征”，ResNet 则在解决“网络敢不敢更深”的问题。
当时的主流思路是“用残差网络做骨架、把 Inception 模块嵌进去”，听起来似乎顺理成章，但实际操作起来有一个尴尬：Inception 模块的分支结构天然会打破残差连接“输入输出同维度”的假设。每个分支输出通道数不同，直接相加根本不可能。2016 年 Szegedy 团队发表的论文Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning正是冲着这个矛盾去的，他们给出了一套完整的残差化改造方案。
1.2 残差连接补上了什么短板
论文里有个很值得注意的实验结论：相同计算量下，加了残差连接的 Inception 网络收敛速度比不带残差的结构快得多，而且最终精度也更高。你自己训练时也能感受出来——没有残差连接时，从随机初始化开始训一个几十层的 Inception 网络，前期 loss 下降慢得让人怀疑人生；一旦在关键位置上加了短路，训练曲线会明显“顺”起来。
一个比较直观的理解是：Inception 的每个模块特征表达能力很强，但它本质上是一个复杂的非线性变换，梯度经过这种复杂变换时很容易被稀释。残差连接相当于给每个模块开了一条“绿色通道”，让梯度可以不经过这些复杂变换直接流到更浅的层。毕竟设计网络要考虑的不只是“前向表达能力强不强”，还有“反向传播时梯度到不到得了浅层”。
所以 Inception-ResNet 并不是追求“用残差替代 Inception 的某部分”，而是“保留 Inception 的强表达力，同时用残差解决训练难度”，两者各管一段，互不干扰。
2. 网络骨架：五段式结构的模块组成与空间尺寸变化
2.1 一张图看懂整体流程
Inception-ResNet v1 和 v2 的结构骨架是完全一致的，可以概括为五段式：
输入(299×299) → Stem：卷积+池化混合下采样，得到 35×35×256 → Inception-ResNet-A × 5：保持空间尺寸不变，提取多尺度特征 → Reduction-A：35×35 → 17×17，通道数扩展到 896 → Inception-ResNet-B × 10：17×17 尺度上的多尺度特征 → Reduction-B：17×17 → 8×8，通道数扩展到 1792 → Inception-ResNet-C × 5：8×8 尺度上的多尺度特征 → 1×1 卷积降维到 1536 → 全局平均池化 → Dropout → 全连接分类层这个设计里有个有意思的地方：A/B/C 三种模块的分支结构会越来越“细长”。A 模块用普通 3x3 卷积，B 模块把 3x3 拆成 1x7+7x1，C 模块再进一步把 3x3 拆成 1x3+3x1。原因很简单——特征图越小，越适合用细长的非对称卷积核，既能降低参数量，又能增加非线性层次。这种“由粗到细”的尺度编排是 Inception 家族一脉相承的设计语言。
2.2 v1 与 v2 的差异：轻量与重量级设计的取舍
很多人误以为 v2 只是 v1 的“加深版本”，其实模块数量完全一样，A/B/C 都是 5/10/5 的堆叠，真正的区别在两方面：
- Stem 复杂度：v2 的 Stem 在 35×35 分辨率阶段加入了一个类似 Inception-A 的小型分支结构（包含多个并行卷积），而 v1 的 Stem 只是简单的卷积+池化链。这意味着 v2 从一开始就能提取更丰富的低层特征，但计算量也更大。
- 模块内部通道数：v2 的 A/B/C 模块每个分支的通道数都比 v1 多出不少，下面这个表是我实现时采用的配置（参考主流开源实现整理，与论文原表在个别通道数上略有差异，但整体比例一致）：
| 模块 | Inception-ResNet-v1 | Inception-ResNet-v2 |
|---|---|---|
| Stem 输出 | 35×35×256 | 35×35×256 |
| Block-A 各分支输出 | 32 / 32 / 64 | 64 / 64 / 96 |
| reduce 后 Block-A 输出 | 256 | 256 |
| Block-B 各分支输出 | 128 / 128 / 128 | 192 / 192 / 256 |
| reduce 后 Block-B 输出 | 896 | 896 |
| Block-C 各分支输出 | 192 / 192 / 192 | 256 / 256 / 320 |
| reduce 后 Block-C 输出 | 1792 | 1792 |
| 分类前特征维度 | 1536 | 1536 |
从表里能看出一个核心思想：v1 和 v2 的空间尺寸变换路径相同，但 v2 在每个模块的宽度上更大胆，这正是它的计算量接近 Inception-v4、远超 v1 的原因。实际使用中，如果你的任务不算复杂（比如小规模分类、特征提取），v1 往往够用且显存友好；如果追求极致精度且算力充足，v2 是更好的选择。
3. 关键设计细节拆解
3.1 非对称卷积：B/C 模块里的细长卷积核
Inception-ResNet 从 Inception v3 继承了非对称卷积分解的思想。以 B 模块为例，它的 branch1 结构是：
1×1 卷积 → 1×7 卷积（左右 padding） → 7×1 卷积（上下 padding）这个结构在数学上与一个 7×7 卷积的感受野相同，但参数量从7×7×C_in×C_out降到了1×7×C_in×C_out + 7×1×C_in×C_out = 14×C_in×C_out（7x7 是 49x C_in x C_out），直接省掉约 71% 参数。更关键的是，1×7 和 7×1 之间夹了一个 ReLU，多了一层非线性，网络表达能力反而更强了。
B 模块的 branch2 会在 branch1 的基础上再重复一次“1×7→7×1”，形成四层叠放，感受野更宽，但参数增加仍然可控。C 模块在 8×8 小特征图上用的是 1×3+3×1，逻辑完全一致——特征图越小，卷积核越应该“细长化”，这是一个在实践中很值得迁移到自定义网络里的经验。
实现时要注意 padding 的写法。nn.Conv2d支持元组形式的 kernel_size 和 padding，比如nn.Conv2d(128, 128, (1, 7), padding=(0, 3))，表示卷积核宽 7 高 1，只在宽度方向左右各补 3；对应的(7, 1), padding=(3, 0)则在高度方向上下各补 3。这样能保证输出特征图空间尺寸不变。
3.2 残差支路里的 1×1 卷积：维度对齐的关键
残差连接的加法要求“输入张量”和“经过模块处理后的输出张量”尺寸完全一致。Inception 的多个分支 concat 后的通道数必然不等于输入通道数，所以在残差支路的末尾必须放一个 1×1 卷积，把 concat 后的通道数压回输入通道数：
concat(分支0, 分支1, 分支2) → 1×1卷积 → 与输入逐元素相加 → ReLU这个 1×1 卷积值得单独强调——它不仅是维度对齐工具，也是一次跨通道的信息融合。三个分支提取的特征在通道维度上还比较“松散”，经过 1×1 卷积后才能真正融合成一组高维特征，再作为残差补充到输入上。我在自己的实现里给这个卷积设了bias=False，因为后面没有接 BN（原因见 3.4），保留 bias 反而会让初始化变复杂。
3.3 scaling 缩放因子：滤波器数量变大时的训练稳定性秘诀
论文里有个容易被忽略但极其重要的细节：当 Inception 模块中滤波器数量较多时，残差连接会导致训练早期不稳定。原因不复杂——残差支路在随机初始化时输出不是零，大量滤波器叠加会让残差信号过大，干扰主路径的稳定更新。
论文的解决方法简单粗暴：把残差支路的输出乘一个缩放系数，实验中最稳定的值是 0.1。也就是：
output = relu(x + scale * conv1x1(concat(branch0, branch1, branch2)))这个scale在 v1 和 v2 上表现不同。v1 因为模块本身通道数少、残差幅度小，scale=1.0 也能稳定训练；v2 的模块宽度大，我实际测试中 scale=0.1 几乎必须加，否则前几个 epoch 的 loss 容易出现明显抖动。你可以把 scale 理解成一个“残差音量旋钮”——宽度越大，音量越要调低。
3.4 为什么残差相加后不再接 BN
一个正常的卷积块通常是“卷积→BN→ReLU”，但在 Inception-ResNet 里，残差相加之后直接接 ReLU，没有 BN。论文作者专门解释过：在残差连接之后再放 BN 会导致显存占用大幅上升，因为 BN 需要保留前向传播的统计量用于反向传播，而每个残差块的输出都要参与后续所有层的梯度计算，额外放一层 BN 等于给每个大模块都套了一个“统计量包袱”。
但这并不意味着整个网络不用 BN。事实上每个卷积后面仍然有 BN，只是在“加法融合”这个位置刻意省掉了 BN。我自己复现时尝试过在相加之后补 BN，结果精度并没有提升，显存却明显涨了——论文的结论在实践里是成立的。
4. PyTorch 实现：从基础组件到完整网络
4.1 基础卷积组件与 Stem 实现
整个网络中的所有普通卷积都遵循“Conv → BN → ReLU”的结构，我封装成一个BasicConv2d。注意这里用了eps=0.001，与 Inception 系列论文保持一致，比 PyTorch 默认的1e-5稍大。
import torch import torch.nn as nn class BasicConv2d(nn.Module): def __init__(self, in_ch, out_ch, kernel_size, stride=1, padding=0): super().__init__() self.conv = nn.Conv2d(in_ch, out_ch, kernel_size, stride, padding, bias=False) self.bn = nn.BatchNorm2d(out_ch, eps=0.001) self.relu = nn.ReLU(inplace=True) def forward(self, x): return self.relu(self.bn(self.conv(x)))Stem 部分是整张网络的下采样主力。v1 的 Stem 是一条直线的“卷积+最大池化”链，把 299×299 一路降到 35×35。v2 的 Stem 在 35×35 阶段加入了一个小的 Inception 式分支结构，低层特征更丰富，代码也稍微复杂一些。
class StemV1(nn.Module): def __init__(self, in_ch=3): super().__init__() self.conv1 = BasicConv2d(in_ch, 32, 3, stride=2) # 299 -> 149 self.conv2 = BasicConv2d(32, 32, 3) # 149 -> 147 self.conv3 = BasicConv2d(32, 64, 3, padding=1) # 147 -> 147 self.pool1 = nn.MaxPool2d(3, stride=2) # 147 -> 73 self.conv4 = BasicConv2d(64, 80, 1) # 73 -> 73 self.conv5 = BasicConv2d(80, 256, 3) # 73 -> 71 self.pool2 = nn.MaxPool2d(3, stride=2) # 71 -> 35 def forward(self, x): x = self.conv1(x) x = self.conv2(x) x = self.conv3(x) x = self.pool1(x) x = self.conv4(x) x = self.conv5(x) x = self.pool2(x) return x class StemV2(nn.Module): """比 v1 多一个 Inception-like 分支结构，低层特征更丰富""" def __init__(self, in_ch=3): super().__init__() self.conv1 = BasicConv2d(in_ch, 32, 3, stride=2) # 299 -> 149 self.conv2 = BasicConv2d(32, 32, 3) # 149 -> 147 self.conv3 = BasicConv2d(32, 64, 3, padding=1) # 147 -> 147 self.pool1 = nn.MaxPool2d(3, stride=2) # 147 -> 73 self.conv4 = BasicConv2d(64, 80, 1) # 73 -> 73 self.conv5 = BasicConv2d(80, 192, 3) # 73 -> 71 self.pool2 = nn.MaxPool2d(3, stride=2) # 71 -> 35 # 35x35 阶段的并行分支结构 self.branch0 = BasicConv2d(192, 96, 1) self.branch1 = nn.Sequential( BasicConv2d(192, 48, 1), BasicConv2d(48, 64, 5, padding=2), ) self.branch2 = nn.Sequential( BasicConv2d(192, 64, 1), BasicConv2d(64, 96, 3, padding=1), BasicConv2d(96, 96, 3, padding=1), ) self.branch3 = nn.Sequential( nn.AvgPool2d(3, stride=1, padding=1), BasicConv2d(192, 96, 1), ) self.conv6 = BasicConv2d(96 + 64 + 96 + 96, 256, 1) def forward(self, x): x = self.conv1(x) x = self.conv2(x) x = self.conv3(x) x = self.pool1(x) x = self.conv4(x) x = self.conv5(x) x = self.pool2(x) x0 = self.branch0(x) x1 = self.branch1(x) x2 = self.branch2(x) x3 = self.branch3(x) x = torch.cat([x0, x1, x2, x3], dim=1) x = self.conv6(x) return x4.2 Inception-ResNet-A/B/C 模块实现
三个模块的结构完全同构，差别只在分支数量、卷积分解方式和通道数上。A 模块负责 35×35 分辨率，分支里用普通 3×3；B 模块在 17×17 上把 3×3 拆成 1×7+7×1；C 模块在 8×8 上拆成 1×3+3×1。代码里我把 channel 参数全部显式传进来，这样 v1 和 v2 就可以复用同一套模块定义。
class InceptionResNetA(nn.Module): def __init__(self, in_ch=256, ch1=32, ch2=32, ch3=64, scale=1.0): super().__init__() self.scale = scale self.branch0 = BasicConv2d(in_ch, ch1, 1) self.branch1 = nn.Sequential( BasicConv2d(in_ch, ch2, 1), BasicConv2d(ch2, ch2, 3, padding=1), ) self.branch2 = nn.Sequential( BasicConv2d(in_ch, ch3, 1), BasicConv2d(ch3, ch3, 3, padding=1), BasicConv2d(ch3, ch3, 3, padding=1), ) self.conv = nn.Conv2d(ch1 + ch2 + ch3, in_ch, 1, bias=False) self.relu = nn.ReLU(inplace=True) def forward(self, x): x0 = self.branch0(x) x1 = self.branch1(x) x2 = self.branch2(x) out = torch.cat([x0, x1, x2], dim=1) out = self.conv(out) * self.scale return self.relu(x + out) class InceptionResNetB(nn.Module): def __init__(self, in_ch=896, ch1=128, ch2=128, ch3=128, scale=1.0): super().__init__() self.scale = scale self.branch0 = BasicConv2d(in_ch, ch1, 1) self.branch1 = nn.Sequential( BasicConv2d(in_ch, ch2, 1), BasicConv2d(ch2, ch2, (1, 7), padding=(0, 3)), BasicConv2d(ch2, ch2, (7, 1), padding=(3, 0)), ) self.branch2 = nn.Sequential( BasicConv2d(in_ch, ch3, 1), BasicConv2d(ch3, ch3, (1, 7), padding=(0, 3)), BasicConv2d(ch3, ch3, (7, 1), padding=(3, 0)), BasicConv2d(ch3, ch3, (1, 7), padding=(0, 3)), BasicConv2d(ch3, ch3, (7, 1), padding=(3, 0)), ) self.conv = nn.Conv2d(ch1 + ch2 + ch3, in_ch, 1, bias=False) self.relu = nn.ReLU(inplace=True) def forward(self, x): x0 = self.branch0(x) x1 = self.branch1(x) x2 = self.branch2(x) out = torch.cat([x0, x1, x2], dim=1) out = self.conv(out) * self.scale return self.relu(x + out) class InceptionResNetC(nn.Module): def __init__(self, in_ch=1792, ch1=192, ch2=192, ch3=192, scale=1.0): super().__init__() self.scale = scale self.branch0 = BasicConv2d(in_ch, ch1, 1) self.branch1 = nn.Sequential( BasicConv2d(in_ch, ch2, 1), BasicConv2d(ch2, ch2, (1, 3), padding=(0, 1)), BasicConv2d(ch2, ch2, (3, 1), padding=(1, 0)), ) self.branch2 = nn.Sequential( BasicConv2d(in_ch, ch3, 1), BasicConv2d(ch3, ch3, (1, 3), padding=(0, 1)), BasicConv2d(ch3, ch3, (3, 1), padding=(1, 0)), BasicConv2d(ch3, ch3, (1, 3), padding=(0, 1)), BasicConv2d(ch3, ch3, (3, 1), padding=(1, 0)), ) self.conv = nn.Conv2d(ch1 + ch2 + ch3, in_ch, 1, bias=False) self.relu = nn.ReLU(inplace=True) def forward(self, x): x0 = self.branch0(x) x1 = self.branch1(x) x2 = self.branch2(x) out = torch.cat([x0, x1, x2], dim=1) out = self.conv(out) * self.scale return self.relu(x + out)这里有个容易写错的地方：nn.Conv2d的 kernel_size 和 padding 如果传元组，顺序是(height, width)。所以(1, 7)配padding=(0, 3)表示卷积核高度为 1、宽度为 7，只在宽度方向补 3；(7, 1)配padding=(3, 0)则只在高度方向补 3。刚上手非对称卷积时弄反这个顺序会直接导致维度对不上，报错信息还很绕。
4.3 Reduction 缩减模块实现
Reduction 模块负责把特征图尺寸减半，同时把通道数翻倍。它也采用多分支并行结构，每个分支用 stride=2 的下采样卷积或池化，最后 concat 到一起。
class ReductionA(nn.Module): def __init__(self, in_ch=256): super().__init__() self.branch0 = BasicConv2d(in_ch, 384, 3, stride=2) self.branch1 = nn.Sequential( BasicConv2d(in_ch, 256, 1), BasicConv2d(256, 256, 3, stride=2), ) self.branch2 = nn.MaxPool2d(3, stride=2) def forward(self, x): x0 = self.branch0(x) x1 = self.branch1(x) x2 = self.branch2(x) return torch.cat([x0, x1, x2], dim=1) class ReductionB(nn.Module): def __init__(self, in_ch=896): super().__init__() self.branch0 = nn.Sequential( BasicConv2d(in_ch, 256, 1), BasicConv2d(256, 384, 3, stride=2), ) self.branch1 = nn.Sequential( BasicConv2d(in_ch, 256, 1), BasicConv2d(256, 256, 3, stride=2), ) self.branch2 = nn.Sequential( BasicConv2d(in_ch, 256, 1), BasicConv2d(256, 256, 3, stride=2), ) self.branch3 = nn.MaxPool2d(3, stride=2) def forward(self, x): x0 = self.branch0(x) x1 = self.branch1(x) x2 = self.branch2(x) x3 = self.branch3(x) return torch.cat([x0, x1, x2, x3], dim=1)计算一下维度就清楚了：ReductionA 输入 35×35×256，三个分支分别输出 384、256、256 通道，concat 得到 17×17×896；ReductionB 输入 17×17×896，四个分支分别输出 384、256、256、896 通道，concat 得到 8×8×1792。注意两个 Reduction 的通道数是固定的，不应随 v1/v2 的模块通道数改变，这是整个骨架的“锚点”。
4.4 完整网络组装与输出验证
把各模块按五段式骨架拼起来。v1 和 v2 的差异通过传入不同 channel 参数体现，代码上只需要两个 shell class。
class InceptionResNetV1(nn.Module): def __init__(self, num_classes=1000): super().__init__() self.stem = StemV1() self.block35 = nn.Sequential(*[ InceptionResNetA(256, 32, 32, 64, scale=1.0) for _ in range(5) ]) self.reduction_a = ReductionA(256) self.block17 = nn.Sequential(*[ InceptionResNetB(896, 128, 128, 128, scale=1.0) for _ in range(10) ]) self.reduction_b = ReductionB(896) self.block8 = nn.Sequential(*[ InceptionResNetC(1792, 192, 192, 192, scale=1.0) for _ in range(5) ]) self.conv = BasicConv2d(1792, 1536, 1) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(0.2) self.fc = nn.Linear(1536, num_classes) def forward(self, x): x = self.stem(x) x = self.block35(x) x = self.reduction_a(x) x = self.block17(x) x = self.reduction_b(x) x = self.block8(x) x = self.conv(x) x = self.avgpool(x) x = torch.flatten(x, 1) x = self.dropout(x) x = self.fc(x) return x class InceptionResNetV2(nn.Module): def __init__(self, num_classes=1000): super().__init__() self.stem = StemV2() self.block35 = nn.Sequential(*[ InceptionResNetA(256, 64, 64, 96, scale=0.1) for _ in range(5) ]) self.reduction_a = ReductionA(256) self.block17 = nn.Sequential(*[ InceptionResNetB(896, 192, 192, 256, scale=0.1) for _ in range(10) ]) self.reduction_b = ReductionB(896) self.block8 = nn.Sequential(*[ InceptionResNetC(1792, 256, 256, 320, scale=0.1) for _ in range(5) ]) self.conv = BasicConv2d(1792, 1536, 1) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(0.2) self.fc = nn.Linear(1536, num_classes) def forward(self, x): x = self.stem(x) x = self.block35(x) x = self.reduction_a(x) x = self.block17(x) x = self.reduction_b(x) x = self.block8(x) x = self.conv(x) x = self.avgpool(x) x = torch.flatten(x, 1) x = self.dropout(x) x = self.fc(x) return x写完第一件事不是训练，而是用随机输入验证各阶段输出尺寸。我在调试时直接打印每一层的 shape，这一步能帮你快速发现 padding 写错、通道数不匹配等问题：
if __name__ == "__main__": for name, model in [("v1", InceptionResNetV1(num_classes=10)), ("v2", InceptionResNetV2(num_classes=10))]: x = torch.randn(2, 3, 299, 299) y = model(x) print(name, y.shape) # 期望输出: v1 torch.Size([2, 10]) # v2 torch.Size([2, 10])如果只想看中间特征图的尺寸，可以临时在 forward 里加 print，或者用下面的 hook 方式：
def print_shapes(model, input_tensor): def hook_fn(name): def fn(module, input, output): print(f"{name}: {output.shape}") return fn hooks = [ model.stem.register_forward_hook(hook_fn("stem")), model.block35.register_forward_hook(hook_fn("block35")), model.reduction_a.register_forward_hook(hook_fn("reduction_a")), model.block17.register_forward_hook(hook_fn("block17")), model.reduction_b.register_forward_hook(hook_fn("reduction_b")), model.block8.register_forward_hook(hook_fn("block8")), model.conv.register_forward_hook(hook_fn("conv")), model.avgpool.register_forward_hook(hook_fn("avgpool")), ] model(input_tensor) for h in hooks: h.remove()实测时 v1 和 v2 在这个实现下都能输出预期的[2, 10]维度，说明空间尺寸和通道数都对齐了。
5. 复现实战经验与避坑指南
5.1 输入尺寸、batch size 与显存控制
Inception-ResNet 的输入尺寸是 299×299，这点和 Inception-v3 一样。如果你用预训练模型做迁移学习，预处理必须和训练时保持一致——Resize 到 299×299、用均值和标准差做标准化，而不是常规的 224×224。我在初学时图省事直接按 224 输入，结果前向传播到一半就报维度错误，排查半天才意识到是输入尺寸问题。
显存方面，v1 在单卡 11GB 的 GPU 上可以跑到 batch size 32，v2 因为模块更宽，同样的显存只能跑到 16 甚至 8。如果显存吃紧，可以优先考虑 v1；如果必须用 v2，又不方便换大卡，可以把分类头之前的几个 Block-C 换成 v1 的配置，整体效果仍然不错。v2 的 Dropout 我习惯设 0.2，和论文一致；迁移学习时如果想加强正则可以调到 0.3，但太多会影响收敛速度。
5.2 训练时的 trick 与参数设置
用随机初始化从零训练时，有几个参数值得留意：
- 学习率：Inception 系列对学习率比较敏感，我习惯用 cosine 衰减，初始学习率
0.045配合 5 个 epoch 的 warmup，比直接用常数学习率稳定得多。 - label smoothing：论文里用了 label smoothing（epsilon=0.1），分类层输出的概率分布会更平滑，不容易过拟合。这个 trick 在 ImageNet 这种大数据集上很有用，小数据集上可能表现不明显，但一般也没有副作用。
- BN 的 momentum：BN 的 momentum 我保留默认值，实测不需要额外调整。但有一点值得注意——如果显存只够用小 batch（比如 8），BN 的统计量会很不稳定，此时可以考虑把
track_running_stats=False，或者在多个 batch 上累积统计量。 - 残差 scale 初始化：v2 的 scale=0.1 很关键，如果训练初期 loss 不降反升，先检查这个值。我遇到过两次把 scale 写成 1.0 导致训练崩掉的情况，改成 0.1 后 loss 重新变得平滑。
5.3 与官方实现对照时的几个差异点
如果你拿这份代码和 torchvision、timm 里的 InceptionResNetV2 对比，会发现一些通道数上的差异。这是正常的——原论文的表格本身就不是特别好读，每个开源实现都在“贴近论文”和“工程便利”之间做了微调。比如：
- 有的实现把 Stem 最后阶段的通道数设为 192 而不是 256，然后在第一个 Block-A 里用 1×1 卷积做维度扩展。
- 有的实现把 A 模块分支 2 的最后一个 3×3 卷积输出设为 48 而不是 64，concat 后总通道数不同，但残差支路的 1×1 卷积会统一成输入通道数，所以最终输出维度总是对齐的。
- Reduction-B 的分支组合也是重灾区，不同实现的分支输出通道组合不完全相同，但最终 concat 后的 1792 是一致的。
我的建议是：学习阶段以理解结构为主，不要纠结于某个通道数值必须和某一版代码一模一样。只要骨架（Stem → A×5 → Reduction-A → B×10 → Reduction-B → C×5 → 1×1 → Pool）不变、残差连接位置正确、空间尺寸逐层对齐，这套实现就已经具备完整的 Inception-ResNet 灵魂。等你要做正式的精度对比或提交实验时，再引入官方预训练权重并保证预处理完全对齐也不迟。
5.4 把这套结构迁移到自己的任务里
Inception-ResNet 的设计思路完全可以迁移到自定义网络中，不一定非要 299×299 输入。以我自己做细粒度图像分类的经验为例，如果目标是 128×128 的输入，可以把 Stem 里第一个 stride=2 的卷积去掉，让网络在更高分辨率上多处理一段，Block-B 的数量从 10 减到 4——放宽深度的同时保留多尺度表达能力，效果往往比直接套用 ImageNet 结构更好。如果任务只需要特征提取（比如做人脸识别、图像检索），直接把fc之前的 1536 维向量拿出来当 embedding 即可，配合 ArcFace 这类度量学习损失非常常见。
另外，如果你需要把网络接到 FPN 这类检测分割框架里，Inception-ResNet 天然适合——Block-A/B/C 输出的三个尺度（35×35、17×17、8×8）正好可以作为特征金字塔的不同层级使用，这是我在一个目标检测小项目里发现的额外价值。多尺度表达不只是对分类有效，对检测分割同样友好。
最后补一个我踩过好多次的坑：Pytorch 里nn.MaxPool2d(3, stride=2)和nn.Conv2d(..., stride=2)在偶数尺寸输入上的向下取整方式不同，可能导致两个分支的空间尺寸差 1，concat 时报错。Reduction 模块里我特意让所有分支的输出尺寸都精确计算过——35 变成 17、17 变成 8 都是能整除的，但在自定义下采样倍数时一定要格外小心。如果报错信息指向 concat 维度不一致，99% 是某一个 stride=2 的分支 padding 少算了 1，手动算一遍每层输出尺寸，比盯着报错日志猜要快得多。
