当前位置：首页 > news >正文

别再死记ResNet结构了！用Python手搓一个ResUnet，从代码里真正搞懂残差连接

news 2026/5/24 1:35:10

从零实现ResUnet：用Python代码彻底理解残差连接的本质

在计算机视觉领域，图像分割一直是极具挑战性的任务之一。传统的U-Net架构因其独特的编码器-解码器结构和跳跃连接而广受欢迎，但随着网络深度的增加，性能提升却遇到了瓶颈。这时，ResNet提出的残差连接机制为我们打开了一扇新的大门。本文将带你用PyTorch从零开始构建一个ResUnet模型，通过实际的代码编写过程，深入理解残差连接如何解决深度神经网络中的退化问题。

1. 残差连接的核心思想与实现

1.1 为什么需要残差连接？

深度神经网络在理论上应该随着层数增加而获得更强的表达能力，但实践中我们常常观察到相反的现象：更深的网络反而表现更差。这种现象被称为"网络退化"，它既不是过拟合，也不是梯度消失导致的。

残差连接(Residual Connection)的提出正是为了解决这一问题。其核心思想是：与其让网络直接学习目标映射H(x)，不如让它学习残差F(x)=H(x)-x，然后将输入x与学习到的残差F(x)相加得到最终输出。这种设计使得网络至少能够保留输入信息(恒等映射)，从而避免了性能退化。

1.2 基础残差块的PyTorch实现

让我们从最基本的残差块开始编码。以下是一个标准的残差块实现：

import torch import torch.nn as nn class BasicResidualBlock(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.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) # 当输入输出维度不匹配时，使用1x1卷积调整维度 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): residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out += self.shortcut(residual) # 残差连接 out = self.relu(out) return out

这个实现中有几个关键点需要注意：

维度匹配问题：当残差块的输入输出通道数或空间尺寸不一致时，需要使用1x1卷积进行调整
批归一化：每个卷积层后都跟随批归一化，有助于稳定训练
激活函数位置：ReLU在残差相加之后再次应用

提示：在实际应用中，残差块可以有多种变体，如Bottleneck结构(使用1x1卷积先降维再升维)在更深的网络中效果更好。

2. 构建ResUnet编码器

2.1 编码器结构设计

ResUnet的编码器部分由多个下采样阶段组成，每个阶段包含若干个残差块。与原始ResNet不同，我们需要保留中间层的特征图用于后续的解码器跳跃连接。

class ResUnetEncoder(nn.Module): def __init__(self, in_channels=3, base_channels=64, num_blocks=[2,2,2,2]): super().__init__() self.initial = nn.Sequential( nn.Conv2d(in_channels, base_channels, kernel_size=7, stride=2, padding=3, bias=False), nn.BatchNorm2d(base_channels), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1) ) self.encoder_stages = nn.ModuleList() in_ch = base_channels for i, num in enumerate(num_blocks): out_ch = base_channels * (2**i) stage = self._make_stage(in_ch, out_ch, num, stride=1 if i==0 else 2) self.encoder_stages.append(stage) in_ch = out_ch def _make_stage(self, in_channels, out_channels, num_blocks, stride): layers = [] layers.append(BasicResidualBlock(in_channels, out_channels, stride)) for _ in range(1, num_blocks): layers.append(BasicResidualBlock(out_channels, out_channels, stride=1)) return nn.Sequential(*layers) def forward(self, x): skips = [] x = self.initial(x) for stage in self.encoder_stages: x = stage(x) skips.append(x) # 保存特征图用于跳跃连接 return x, skips[:-1] # 返回最终特征和中间特征(去掉最后一个)

2.2 编码器实现细节

初始卷积层：使用较大的7x7卷积核和步长2，快速降低特征图尺寸
多阶段设计：每个阶段将通道数翻倍，空间尺寸减半(通过第一个残差块的stride=2实现)
特征保存：forward方法返回最终特征和中间特征图，供解码器使用

注意：最后一个中间特征图不需要保存，因为它就是编码器的最终输出。

3. 构建ResUnet解码器

3.1 解码器结构设计

解码器的任务是逐步上采样特征图并恢复空间细节。每个解码阶段由转置卷积(或双线性插值)上采样和残差块组成，并与编码器对应阶段的特征图进行拼接。

class ResUnetDecoder(nn.Module): def __init__(self, base_channels=64, num_blocks=[2,2,2,2]): super().__init__() self.decoder_stages = nn.ModuleList() num_stages = len(num_blocks) for i in range(num_stages): in_ch = base_channels * (2**(num_stages - i - 1)) out_ch = in_ch // 2 stage = nn.Sequential( nn.ConvTranspose2d(in_ch, out_ch, kernel_size=2, stride=2), BasicResidualBlock(out_ch * 2, out_ch) # 拼接后通道数翻倍 ) self.decoder_stages.append(stage) self.final = nn.Conv2d(base_channels, 1, kernel_size=1) # 假设二分类 def forward(self, x, skips): for i, stage in enumerate(self.decoder_stages): x = stage[0](x) # 上采样 x = torch.cat([x, skips[-(i+1)]], dim=1) # 跳跃连接 x = stage[1](x) # 残差块 return self.final(x)

3.2 解码器关键实现点

上采样操作：使用转置卷积实现，也可以替换为双线性插值+卷积的组合
特征拼接：将编码器对应阶段的特征图与上采样结果沿通道维度拼接
残差处理：拼接后的特征通过残差块进一步融合信息

4. 完整ResUnet模型与训练技巧

4.1 整合编码器与解码器

现在我们将编码器和解码器组合成完整的ResUnet模型：

class ResUnet(nn.Module): def __init__(self, in_channels=3, base_channels=64, num_classes=1): super().__init__() self.encoder = ResUnetEncoder(in_channels, base_channels) self.decoder = ResUnetDecoder(base_channels) def forward(self, x): x, skips = self.encoder(x) x = self.decoder(x, skips) return x

4.2 模型训练中的实用技巧

学习率策略：残差网络通常需要较大的初始学习率，配合适当的学习率衰减

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=3)

损失函数选择：对于图像分割任务，Dice损失+BCE损失的组合通常效果不错

def dice_loss(pred, target, smooth=1.): pred = pred.sigmoid() intersection = (pred * target).sum() return 1 - (2. * intersection + smooth) / (pred.sum() + target.sum() + smooth) criterion = lambda pred, target: nn.BCEWithLogitsLoss()(pred, target) + dice_loss(pred, target)

数据增强：适当的数据增强可以显著提升模型泛化能力

train_transform = A.Compose([ A.RandomRotate90(), A.Flip(), A.RandomBrightnessContrast(), A.GaussNoise(), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])