全卷积网络(FCN)在图像分割中的原理剖析与实战优化

1次阅读

没有评论

共计 3027 个字符，预计需要花费 8 分钟才能阅读完成。

图像分割任务从早期的阈值法、边缘检测，发展到基于传统机器学习的区域生长、Graph Cut 方法，最终在深度学习时代迎来突破。传统 CNN 在分类任务中表现出色，但存在两个致命缺陷：

全连接层会破坏空间位置信息
固定尺寸输出无法适应像素级预测

全卷积网络 (FCN) 通过三个关键创新解决这些问题：

全卷积化：替换全连接层为 1 ×1 卷积，保持空间维度
转置卷积：实现可学习的上采样(learnable upsampling)
跳跃连接：融合深浅层特征提升细节恢复能力

编码器部分通常采用预训练分类网络（如 VGG16），通过逐步下采样提取高级语义特征。解码器则负责：

使用转置卷积逐步扩大特征图尺寸
与编码器对应层特征进行跳跃连接
通过 1 ×1 卷积调整通道数匹配分割类别

数学表达上，设输入为 $X \in \mathbb{R}^{H×W×3}$，编码过程可表示为：

$$ f_e = E(X), \quad f_e \in \mathbb{R}^{\frac{H}{32}×\frac{W}{32}×512} $$

解码过程则包含上采样和特征融合：

$$ f_d = D(f_e) + Skip(E_{mid}(X)) $$

转置卷积 (transposed convolution) 不是简单的逆卷积，其本质是通过插入零值实现扩张输入，再进行标准卷积运算。以 stride= 2 的 3 ×3 卷积为例：

在输入特征图每个像素间插入 1 个零值
用 3 ×3 卷积核进行滑动计算
输出尺寸满足 $H_{out} = (H_{in}-1)×stride + kernel_size$

PyTorch 实现示例：

self.upsample = nn.ConvTranspose2d(
    in_channels=512,
    out_channels=256,
    kernel_size=3,
    stride=2,
    padding=1,
    output_padding=1 
)

FCN-8s（效果最佳版本）采用三级跳跃连接：

pool3 层（1/ 8 分辨率）
pool4 层（1/16 分辨率）
最终特征（1/32 分辨率）

特征融合时需注意：

通过 1 ×1 卷积统一通道数
上采样到相同尺寸后逐元素相加
使用 ReLU 激活增强非线性

class FCN8s(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        # 编码器（基于预训练 VGG16）vgg = models.vgg16(pretrained=True)
        self.features = vgg.features

        # 解码器组件
        self.conv6 = nn.Conv2d(512, 4096, 7, padding=3)
        self.conv7 = nn.Conv2d(4096, 4096, 1)
        self.score_fr = nn.Conv2d(4096, num_classes, 1)
        self.upscore2 = nn.ConvTranspose2d(num_classes, num_classes, 4, stride=2, padding=1)

        # 跳跃连接路径
        self.score_pool4 = nn.Conv2d(512, num_classes, 1)
        self.upscore_pool4 = nn.ConvTranspose2d(num_classes, num_classes, 4, stride=2, padding=1)
        self.score_pool3 = nn.Conv2d(256, num_classes, 1)
        self.upscore8 = nn.ConvTranspose2d(num_classes, num_classes, 16, stride=8, padding=4)

    def forward(self, x):
        # 编码过程
        pool3 = self.features[:17](x)  # 1/8
        pool4 = self.features[17:24](pool3)  # 1/16
        pool5 = self.features[24:](pool4)  # 1/32

        # 解码主干
        x = F.relu(self.conv6(pool5))
        x = F.dropout(x, 0.5)
        x = F.relu(self.conv7(x))
        x = F.dropout(x, 0.5)
        x = self.score_fr(x)

        # 融合 pool4 特征
        upscore2 = self.upscore2(x)
        score_pool4 = self.score_pool4(pool4)
        x = upscore2 + score_pool4

        # 融合 pool3 特征
        upscore_pool4 = self.upscore_pool4(x)
        score_pool3 = self.score_pool3(pool3)
        x = upscore_pool4 + score_pool3

        return self.upscore8(x)

学习率策略：

scheduler = torch.optim.lr_scheduler.OneCycleLR(
    optimizer,
    max_lr=1e-3,
    steps_per_epoch=len(train_loader),
    epochs=50
)

类别不平衡处理：

class_weights = 1 / (class_counts + 1e-6)
criterion = nn.CrossEntropyLoss(weight=class_weights)

混合精度训练：

scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    outputs = model(inputs)
    loss = criterion(outputs, targets)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

使用梯度检查点技术：

from torch.utils.checkpoint import checkpoint
x = checkpoint(self.block, x)  # 前向时临时保存中间结果

调整 batch size 与输入分辨率的关系：

分辨率	最大 batch size	显存占用
512×512	8	10.3GB
384×384	16	9.8GB
256×256	32	8.1GB

# 训练后动态量化
model = torch.quantization.quantize_dynamic(
    model,
    {nn.Conv2d, nn.ConvTranspose2d},
    dtype=torch.qint8
)

# 保存量化模型
torch.jit.save(torch.jit.script(model), 'fcn8s_quantized.pt')