1. 为什么网络越深,效果反而越差了?
如果你刚开始接触深度学习,可能会有一个很自然的想法:既然一个5层的网络能学到一些特征,那我把网络加到50层、100层,它不就能学到更多、更复杂的特征,效果肯定更好吗?这个想法听起来很合理,但现实却给了我们一记重拳。大概在2015年之前,研究者们就发现,当网络层数增加到一定程度后,模型的性能不仅不提升,反而会急剧下降。更让人头疼的是,这种下降不是模型在未知数据上“懵了”,而是在训练数据上,它的表现都变差了。
这就像你请了一位家教,原本每天学习2小时,成绩稳步提升。你觉得“加量不加价”,让他每天学8小时,结果他不仅没学到新东西,连之前会的都忘了。这显然不是“学不动了”,而是“学乱了”。
这种现象被称为网络退化。它不是过拟合,因为过拟合是训练集上表现好、测试集上表现差。而网络退化是连训练集都搞不定。当时大家普遍认为,问题出在“梯度消失”或“梯度爆炸”上,也就是反向传播时,梯度信号在层层传递中变得极其微弱或巨大,导致底层的参数无法有效更新。虽然通过一些技巧(比如更好的初始化、使用BatchNorm层)能缓解这个问题,但并没有从根本上解决深度网络的退化。
直到何恺明大神和他的团队在2015年提出了残差网络,我们才恍然大悟:原来问题可能不是模型“学不会”,而是它“不好学”。他们提出了一个革命性的想法:与其让网络每一层都去拟合一个潜在的复杂映射 H(x),不如让它去拟合一个“残差” F(x) = H(x) - x。这样一来,原本的映射就变成了 H(x) = F(x) + x。
这个“+ x”的操作,就是大名鼎鼎的捷径连接。它让数据可以“抄近路”,直接从一层跳到后面几层。这个简单的设计,让训练数百甚至上千层的深度网络成为了可能,并且一举拿下了当年ImageNet图像识别比赛的冠军。它的核心思想是:如果更深的网络是有效的,那么模型可以轻松地通过残差块中的权重层来学习到新的特征;如果额外的层没什么用,那捷径连接至少能保证信息无损地传递过去,让模型至少不会比浅层网络更差。这相当于给网络训练加了一个“性能保底”。
2. 拆解残差块:从直觉到代码
理解了“为什么”之后,我们来看看“是什么”。残差块是ResNet的基石,它的结构其实非常直观。我们可以把它想象成一条河流的主干道和一条人工开凿的运河。
假设输入数据 x 是河流的源头,我们期望的输出 H(x) 是下游的某个位置。传统的网络就像试图用一系列复杂的水闸和弯道(卷积层、激活函数)来改造整条河流,让水流完全按照新路线走。而残差网络则说:我们保留原来的主干道(x),同时在旁边挖一条小的运河(F(x))来对水流进行微调。最终下游的水是主干道的水和运河水混合的结果(F(x) + x)。这样,即使我们挖的运河工程(深层网络)没起到好作用,至少主干道的水还能正常流下去,不至于让下游干涸。
在具体实现上,一个基础的残差块通常包含两个 3x3 的卷积层,每个卷积层后面都跟着批归一化和ReLU激活函数。那个关键的“捷径连接”,就是把最开始的输入 x,直接加到第二个卷积层的输出之后,然后再经过一个ReLU激活。
import tensorflow as tf
from tensorflow.keras import layers, activations
class Residual(tf.keras.Model):
def __init__(self, num_channels, use_1x1conv=False, strides=1):
super(Residual, self).__init__()
# 第一个卷积层
self.conv1 = layers.Conv2D(num_channels, kernel_size=3, strides=strides, padding='same')
self.bn1 = layers.BatchNormalization()
# 第二个卷积层
self.conv2 = layers.Conv2D(num_channels, kernel_size=3, padding='same')
self.bn2 = layers.BatchNormalization()
# 捷径连接是否需要1x1卷积?这取决于输入输出的形状是否匹配
if use_1x1conv:
self.conv3 = layers.Conv2D(num_channels, kernel_size=1, strides=strides)
else:
self.conv3 = None
def call(self, X):
# 主路径:Conv -> BN -> ReLU -> Conv -> BN
Y = activations.relu(self.bn1(self.conv1(X)))
Y = self.bn2(self.conv2(Y))
# 捷径路径:如果输入X的形状和Y不匹配(比如通道数不同或尺寸不同),就用1x1卷积调整
if self.conv3:
X = self.conv3(X)
# 相加后激活
Y = Y + X
return activations.relu(Y)
这里有个细节需要注意:捷径连接要求相加的两个张量必须具有完全相同的形状(批量大小、高度、宽度、通道数)。当我们需要改变特征图的尺寸(strides > 1)或通道数时,原始的 x 就无法直接和 F(x) 相加了。这时候,use_1x1conv 这个开关就派上用场了。通过一个 1x1 的卷积层,我们可以将输入 x 的通道数和尺寸调整到与主路径输出一致。这个带 1x1 卷积的捷径连接,也被称为“投影捷径”。
2.1 瓶颈结构:更深的网络,更聪明的设计
对于像ResNet-50、101、152这样的超深网络,如果每个残差块都用两个 3x3 卷积,计算量会非常庞大。于是,ResNet引入了瓶颈结构。一个瓶颈残差块包含三个卷积层:1x1、3x3、1x1。
- 第一个
1x1卷积负责降维,减少通道数,降低计算成本。 - 中间的
3x3卷积在较低维度的空间上进行特征提取。 - 最后一个
1x1卷积再负责升维,恢复通道数。
这种“压缩-处理-扩展”的设计,在保证特征提取能力的同时,极大地减少了参数量和计算量。你可以把它看作是一个高效的“数据处理管道”,先聚焦核心信息,处理完再还原。在实际构建ResNet-50及以上的模型时,我们使用的都是这种瓶颈块。
3. 搭建你自己的ResNet模型
知道了砖块(残差块)怎么造,接下来我们看看如何用它们盖起一座大楼(完整的ResNet模型)。ResNet不是一个固定的网络,而是一个家族,包括ResNet-18、34、50、101、152等,数字代表网络的层数。它们的整体架构遵循一个通用的模式。
一个经典的ResNet(如ResNet-34)可以分为以下几个部分:
- 输入处理层:一个
7x7的大卷积核配合stride=2的步幅,以及一个3x3的最大池化层。这一步的目的是快速、粗略地提取底层特征,并降低特征图的尺寸。 - 四个阶段(Stage):这是模型的主体。每个阶段由若干个残差块堆叠而成,并且不同阶段之间,特征图的尺寸会减半(通常通过第一个残差块的
stride=2实现),而通道数会翻倍。这种设计让网络能够在不同尺度上提取特征。 - 输出层:在卷积部分结束后,使用全局平均池化将每个通道的二维特征图压缩成一个标量,然后直接送入全连接层进行分类。这比使用展平层接巨大全连接层要高效得多,也减少了过拟合风险。
下面我们用代码把ResNet-18搭起来,让你感受一下这个结构是如何组装的:
class ResNet(tf.keras.Model):
def __init__(self, num_blocks):
super(ResNet, self).__init__()
# 1. 初始卷积层
self.conv = layers.Conv2D(64, kernel_size=7, strides=2, padding='same')
self.bn = layers.BatchNormalization()
self.relu = layers.Activation('relu')
self.max_pool = layers.MaxPool2D(pool_size=3, strides=2, padding='same')
# 2. 四个残差阶段
# num_blocks 是一个列表,例如 [2, 2, 2, 2] 对应ResNet-18
self.stage1 = self._make_stage(64, num_blocks[0], first_stage=True)
self.stage2 = self._make_stage(128, num_blocks[1])
self.stage3 = self._make_stage(256, num_blocks[2])
self.stage4 = self._make_stage(512, num_blocks[3])
# 3. 输出层
self.global_avg_pool = layers.GlobalAvgPool2D()
self.fc = layers.Dense(units=10, activation='softmax') # 假设是10分类
def _make_stage(self, channels, num_blocks, first_stage=False):
# 创建一个阶段,包含多个残差块
stage = tf.keras.Sequential()
for i in range(num_blocks):
# 每个阶段的第一个块可能需要下采样(stride=2)和调整通道数
if i == 0 and not first_stage:
stage.add(Residual(channels, use_1x1conv=True, strides=2))
else:
stage.add(Residual(channels))
return stage
def call(self, x):
# 前向传播
x = self.conv(x)
x = self.bn(x)
x = self.relu(x)
x = self.max_pool(x)
x = self.stage1(x)
x = self.stage2(x)
x = self.stage3(x)
x = self.stage4(x)
x = self.global_avg_pool(x)
x = self.fc(x)
return x
# 实例化一个ResNet-18
model = ResNet([2, 2, 2, 2])
model.build(input_shape=(None, 224, 224, 3)) # 构建模型,输入为224x224的RGB图像
model.summary() # 打印模型结构
运行 model.summary(),你会看到一个清晰的层级结构,总参数量大约在1100万左右。通过修改 num_blocks 列表,比如使用 [3, 4, 6, 3],就能得到ResNet-34。更深层的模型则使用前面提到的瓶颈块来构建 _make_stage 函数。
4. 实战:用ResNet搞定图像分类任务
理论说得再多,不如亲手跑一遍代码来得实在。这里我们用一个经典的例子——手写数字识别,来演示如何用我们刚搭建的ResNet-18进行训练和评估。虽然MNIST数据集图片很小(28x28),用ResNet有点“杀鸡用牛刀”,但非常适合快速验证流程。
4.1 数据准备与预处理
ResNet通常接受 224x224 大小的输入。我们需要将MNIST的 28x28 图像放大。这里要注意,简单的插值放大并不会增加信息量,但对于理解流程足够了。
import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist
# 加载数据
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# 数据预处理:归一化并调整维度为 NHWC,同时调整大小
def preprocess_images(images, size=224):
# 归一化到 [0, 1]
images = images.astype('float32') / 255.0
# 增加通道维度 (60000, 28, 28) -> (60000, 28, 28, 1)
images = np.expand_dims(images, axis=-1)
# 使用tf.image.resize放大图像。注意:这里方法选择'bilinear'(双线性插值)
images_resized = tf.image.resize(images, [size, size], method='bilinear')
# 为了模拟RGB图像,将单通道复制三份(因为我们的模型输入通道是3)
images_resized = tf.repeat(images_resized, repeats=3, axis=-1)
return images_resized.numpy()
# 处理训练集和测试集
train_images_processed = preprocess_images(train_images)
test_images_processed = preprocess_images(test_images)
print(f"训练集形状: {train_images_processed.shape}")
print(f"测试集形状: {test_images_processed.shape}")
4.2 模型编译与训练
数据准备好后,我们就可以编译和训练模型了。对于分类任务,损失函数通常选择交叉熵,优化器可以选择SGD或Adam。这里我习惯先用Adam快速收敛,后期如果需要精细调优再换到SGD。
# 编译模型
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 开始训练
history = model.fit(train_images_processed, train_labels,
batch_size=32,
epochs=5,
validation_split=0.1) # 用10%的训练数据作为验证集
# 在测试集上评估最终性能
test_loss, test_acc = model.evaluate(test_images_processed, test_labels, verbose=2)
print(f'\n测试集准确率: {test_acc:.4f}')
在实际训练中,你可能会发现几个现象:首先,即使网络有18层,训练初期也非常稳定,没有出现梯度问题,这得益于残差结构和BatchNorm。其次,在MNIST这种简单数据集上,可能很快就能达到接近99%的准确率。但别急,这只是一个开始。
4.3 优化技巧与调参实战
用默认参数跑通只是第一步。要让ResNet在你自己的数据集上发挥最大威力,还需要一些“炼丹”技巧。我结合自己的经验,分享几个关键点:
学习率策略:这是最重要的超参数之一。我强烈推荐使用学习率预热和余弦退火。一开始用很小的学习率训练几个epoch(预热),让模型先“找到感觉”,然后按余弦函数逐渐降低学习率。这能有效避免训练初期的不稳定,并帮助模型收敛到更优的局部最优点。TensorFlow/Keras中可以用 tf.keras.optimizers.schedules.CosineDecay 来实现。
优化器选择:Adam优化器自适应性强,上手快。但对于ResNet这种经典结构,很多顶尖论文和比赛后期都换回了带动量的SGD,因为它往往能找到泛化能力更强的解。我的经验是:前期用Adam快速下降,后期用SGD(动量0.9)配合衰减的学习率进行精调。
数据增强:对于图像任务,数据增强是免费的午餐。除了常见的随机裁剪、水平翻转,对于ResNet,可以尝试:
- CutMix或MixUp:将两张图片混合在一起进行训练,能显著提升模型的鲁棒性和泛化能力。
- AutoAugment或RandAugment:自动搜索或随机组合一系列增强策略,效果拔群。
权重初始化与BatchNorm:ResNet对初始化不那么敏感,这要归功于BatchNorm层。但确保你的BatchNorm层在训练和推理时模式正确(training=True/False)。在微调预训练模型时,冻结BatchNorm的统计量(设置 trainable=False)有时能带来更好的效果。
5. 超越基础:ResNet的变体与演进
ResNet的成功催生了一系列改进版本,它们针对不同问题进行了优化。了解这些变体,能帮助你在不同场景下做出更好的选择。
ResNet-D:这个改进非常实用,它修改了残差块的下采样部分。原始ResNet在下采样时,主路径用 stride=2 的卷积,捷径路径用 1x1 卷积+stride=2。ResNet-D将捷径路径的 1x1 卷积的步幅改为1,但在其前面加了一个 2x2 的平均池化层(stride=2)。同时,主路径的第一个 1x1 卷积步幅也改为1,在其前面加一个 2x2 的平均池化。这个小改动减少了信息损失,在实践中能稳定提升约0.5%的准确率。
ResNeXt:提出了“分组卷积”和“基数”的概念。它不再单纯地增加网络的深度或宽度,而是增加“路径”的数量。一个ResNeXt块有多条并行的、结构相同的变换路径,最后将结果相加。这相当于在残差块中引入了类似Inception的多分支思想,但设计更规整,参数更少,效果更好。
SENet:即“挤压-激励网络”。它的核心思想是让模型学会“关注”重要的通道。在残差块的最后,增加一个全局平均池化来“挤压”全局空间信息,然后通过两个全连接层(形成一个瓶颈结构)来“激励”模型,学习每个通道的重要性权重,最后用这个权重去缩放原始特征。这个轻量级的模块可以嵌在任何CNN架构中,带来明显的性能提升。
在实际项目中,我的选择策略通常是:首选标准的ResNet-50或ResNet-101作为强大的基准模型。如果对精度有极致要求且计算资源充足,可以尝试ResNeXt或SENet。如果是在移动端或边缘设备部署,则会考虑更轻量的变体,或者自己动手对通道数进行裁剪。
6. 常见“坑”与调试心得
纸上得来终觉浅,绝知此事要躬行。在真正用ResNet做项目时,我踩过不少坑,这里分享几个最常见的:
输入尺寸不匹配:这是新手最容易出错的地方。ResNet要求输入尺寸至少大于一定值(例如,ResNet-18/34的输入至少是 32x32,ResNet-50及以上由于瓶颈结构,要求可能更高)。如果你的图片尺寸太小,经过多次下采样后,特征图尺寸会变成 1x1 甚至更小,导致无法计算。务必在模型构建后,用 model.summary() 检查每一层的输出形状,或者用一个小批量数据前向传播一次看看。
梯度爆炸/消失(依然存在):虽然ResNet极大地缓解了这个问题,但并非完全免疫。如果你使用了非常深的自定义网络(比如几百层),并且没有很好地初始化权重或设置BatchNorm,仍然可能遇到。监控训练初期的损失值,如果loss变成NaN,很可能就是梯度爆炸了。解决办法包括:检查初始化、降低初始学习率、使用梯度裁剪。
验证集损失不下降:模型在训练集上表现良好,但验证集损失早早停滞。这通常是过拟合的迹象。除了增加数据增强,可以尝试:更强的正则化(如Dropout,虽然ResNet原文没用,但在小数据集上有效)、标签平滑(Label Smoothing)、以及早停。另外,检查一下你的验证集和训练集的数据分布是否一致,是否存在数据泄露。
训练速度慢:ResNet-50以上的模型参数量较大。加速训练可以:1) 使用混合精度训练,利用现代GPU的Tensor Cores,几乎能带来2-3倍的训练加速,且精度损失极小。2) 增大 batch_size 并相应调整学习率(线性缩放规则)。3) 使用更快的优化器如LAMB,尤其在大批量训练时。
最后,一个最朴素的建议:从一个小型、可控的实验开始。比如先用10%的数据跑1-2个epoch,确保整个数据管道、模型前向反向传播、损失计算都是正确的。然后再逐步放大数据量、增加训练轮数、调整超参数。这能帮你节省大量排错时间。记住,在深度学习中,快速迭代和实验比单纯思考更重要。
912



被折叠的 条评论
为什么被折叠?



