CNN进阶架构：从ResNet到多任务学习实践

原创于 2026-07-03 16:24:08 发布 · 434 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Java

1. 课程背景与核心价值

鲁鹏教授的《计算机视觉与深度学习》课程第十章聚焦CNN进阶架构与应用拓展，系统性地梳理了从基础CNN到现代深度卷积网络的关键技术演进路径。这一章节特别值得关注的原因在于，它并非简单罗列各类网络结构，而是从"深度瓶颈突破"和"多任务落地"两个维度，揭示了卷积神经网络发展的内在逻辑。

作为计算机视觉领域的基石技术，CNN在ImageNet竞赛后经历了爆发式发展。但早期的VGG等网络在深度增加时面临梯度消失、参数爆炸等典型问题。2015年ResNet通过残差连接实现千层网络的稳定训练，标志着第一个重要突破点。随后，DenseNet、MobileNet等架构分别从特征复用和轻量化角度推动技术边界。

在多任务应用层面，课程重点分析了如何通过共享特征提取层、任务特异性分支设计等技术，使单一CNN模型同时处理分类、检测、分割等不同任务。这种设计显著提升了工业场景下的部署效率，也是当前自动驾驶、医疗影像等领域的标准实践。

2. 深度瓶颈突破技术解析

2.1 残差学习机制

ResNet的核心创新在于将传统的直接拟合目标函数H(x)转变为拟合残差F(x)=H(x)-x。这种转变通过快捷连接（shortcut connection）实现，使得梯度可以直接回传到浅层网络。具体实现时需要注意：

当特征图尺寸变化时，快捷连接需要包含1×1卷积进行维度匹配
批量归一化层应放置在卷积层与激活函数之间
瓶颈结构（Bottleneck）采用1×1-3×3-1×1的卷积组合，在保持感受野的同时减少计算量

# PyTorch实现的基础残差块
class BasicBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, 
                              stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3,
                              stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels,
                         kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
    
    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        return F.relu(out)

2.2 注意力机制增强

SE(Squeeze-and-Excitation)模块通过特征通道间的自适应校准，使网络能够强调重要特征、抑制无关特征。其实现分为三个步骤：

Squeeze：全局平均池化将空间信息压缩为通道描述符
Excitation：全连接层生成通道注意力权重
Scale：将权重与原特征图逐通道相乘

class SEBlock(nn.Module):
    def __init__(self, channel, reduction=16):
        super().__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)

实践提示：SE模块会使推理速度下降约10%，在计算资源受限的场景需谨慎使用。通常建议在ResNet的bottleneck结构中添加，且reduction ratio设置为16-32为宜。

3. 轻量化架构设计

3.1 深度可分离卷积

MobileNet系列的核心创新是将标准卷积分解为深度卷积和点卷积两个步骤：

深度卷积：每个输入通道单独使用一个3×3卷积核处理
点卷积：1×1卷积进行通道混合

这种设计将计算复杂度从O(Dk²MNC)降低到O(Dk²MN + MNC)，其中Dk为卷积核尺寸，M、N为输入输出通道数，C为空间分辨率。

操作类型	计算量	参数量	内存访问量
标准卷积	H×W×Dk²×M×N	Dk²×M×N	H×W×(M+N+Dk²×M×N)
深度可分离卷积	H×W×(Dk²×M + M×N)	Dk²×M + M×N	H×W×(2M+N+Dk²×M)

3.2 神经架构搜索(NAS)

ENAS等自动化架构搜索方法通过控制器RNN生成子网络架构，在共享参数的基础上进行性能评估。课程特别强调了几种实用技巧：

搜索空间设计应包含多种卷积类型（标准、可分离、空洞等）
使用参数化α-softmax进行离散架构采样
采用Proximal Policy Optimization进行策略梯度更新

4. 多任务学习框架

4.1 共享-分支架构

课程中详细解析的Multi-Task CNN(MTL)框架包含：

共享骨干网络：通常使用ResNet-50/101等成熟架构
任务特定头部分支：根据任务复杂度设计不同深度
梯度平衡机制：通过uncertainty weighting自动调整各任务损失权重

class MTLModel(nn.Module):
    def __init__(self, backbone='resnet50', num_classes=[10, 20]):
        super().__init__()
        base_model = torchvision.models.__dict__[backbone](pretrained=True)
        self.shared = nn.Sequential(*list(base_model.children())[:-2])
        
        # 任务特定头
        self.head1 = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Linear(2048, num_classes[0])
        )
        self.head2 = nn.Sequential(
            nn.Conv2d(2048, 256, 3, padding=1),
            nn.Upsample(scale_factor=8, mode='bilinear'),
            nn.Conv2d(256, num_classes[1], 1)
        )
        
        # 可学习的不确定性参数
        self.log_vars = nn.Parameter(torch.zeros(2))
    
    def forward(self, x):
        shared_feat = self.shared(x)
        out1 = self.head1(shared_feat)
        out2 = self.head2(shared_feat)
        return out1, out2
    
    def compute_loss(self, preds, targets):
        loss1 = F.cross_entropy(preds[0], targets[0])
        loss2 = F.binary_cross_entropy_with_logits(preds[1], targets[1])
        
        # 不确定性加权
        precision1 = torch.exp(-self.log_vars[0])
        precision2 = torch.exp(-self.log_vars[1])
        
        total_loss = precision1*loss1 + precision2*loss2 + self.log_vars.sum()
        return total_loss