图像分割三巨头：U-Net/DeepLab/Mask R-CNN实战对比

一、真实场景：从细胞核到自动驾驶，我被U-Net坑了

去年参加Kaggle细胞核分割竞赛，U-Net简直神器——在2018年Data Science Bowl数据集上Dice系数0.95，推理速度快（28ms/512x512）。项目交付后被调去自动驾驶团队，任务是分割车道线、车辆、行人。我直接复用U-Net，结果傻眼了：车辆边界锯齿状，远处行人糊成一团，Cityscapes验证集mIoU只有72.3%。

团队建议换DeepLab，我不服：U-Net跳连不是保留边缘信息吗？查论文才发现：U-Net擅长捕捉精细结构（适合医学小目标），但面临大尺度变化和复杂背景时，感受野不够。DeepLab的空洞卷积能扩大感受野，ASPP模块聚合多尺度特征，在Cityscapes上mIoU 81.4%。后来又遇到新需求：不仅要分割出所有车辆，还要区分每辆车（实例分割），U-Net和DeepLab都做不到，只能用Mask R-CNN。

二、问题：不同场景选哪个？一张表看懂

网络	核心思想	适用场景	输出类型	计算量
U-Net	对称编码-解码 + 跳连，保留空间细节	医学图像（细胞、器官）、小目标分割	语义分割（每个像素一个类别）	低（~18 GMACs @512）
DeepLabV3+	空洞卷积 + ASPP + 编码-解码	自动驾驶、遥感图像、大尺度语义分割	语义分割	中（~35 GMACs @512）
Mask R-CNN	Faster R-CNN + RoIAlign + 分割分支	实例分割（区分个体）	实例分割（每个实例掩码+bbox+类别）	高（~80 GMACs @512）

三、方案对比：原理 + 代码实现

3.1 U-Net：对称结构拿捏细节

四个下采样卷积块（每个包含两次3x3卷积+ReLU+2x2最大池化），四个上采样卷积块（转置卷积+跳连）。关键：跳连把下采样每层的特征图拼到对应上采样层，保留低级别边缘信息。

# model_unet.py (PyTorch 2.1)
import torch
import torch.nn as nn

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
        )
    def forward(self, x):
        return self.conv(x)

class UNet(nn.Module):
    def __init__(self, in_channels=3, n_classes=2):
        super().__init__()
        self.enc1 = DoubleConv(in_channels, 64)
        self.pool1 = nn.MaxPool2d(2)
        self.enc2 = DoubleConv(64, 128)
        self.pool2 = nn.MaxPool2d(2)
        self.enc3 = DoubleConv(128, 256)
        self.pool3 = nn.MaxPool2d(2)
        self.enc4 = DoubleConv(256, 512)
        self.pool4 = nn.MaxPool2d(2)
        self.bridge = DoubleConv(512, 1024)
        self.up4 = nn.ConvTranspose2d(1024, 512, 2, 2)
        self.dec4 = DoubleConv(1024, 512)
        self.up3 = nn.ConvTranspose2d(512, 256, 2, 2)
        self.dec3 = DoubleConv(512, 256)
        self.up2 = nn.ConvTranspose2d(256, 128, 2, 2)
        self.dec2 = DoubleConv(256, 128)
        self.up1 = nn.ConvTranspose2d(128, 64, 2, 2)
        self.dec1 = DoubleConv(128, 64)
        self.out = nn.Conv2d(64, n_classes, 1)
    def forward(self, x):
        e1 = self.enc1(x)
        e2 = self.enc2(self.pool1(e1))
        e3 = self.enc3(self.pool2(e2))
        e4 = self.enc4(self.pool3(e3))
        b = self.bridge(self.pool4(e4))
        d4 = self.dec4(torch.cat([self.up4(b), e4], dim=1))
        d3 = self.dec3(torch.cat([self.up3(d4), e3], dim=1))
        d2 = self.dec2(torch.cat([self.up2(d3), e2], dim=1))
        d1 = self.dec1(torch.cat([self.up1(d2), e1], dim=1))
        return self.out(d1)

3.2 DeepLabV3+：ASPP多尺度聚合

主干通常用ResNet101（带空洞卷积的输入层后4层），ASPP包含1x1卷积和3个不同膨胀率（6,12,18）的3x3空洞卷积，再加全局平均池化。输出拼接到一起，经1x1卷积后上采样。解码器简单：将ASPP输出4倍上采样，与主干低层特征（经1x1卷积降维）拼接，再3x3卷积细化。

# model_deeplab.py
import torch
import torch.nn as nn
import torchvision.models as models

class ASPP(nn.Module):
    def __init__(self, in_ch, out_ch, rates=[6,12,18]):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 1)
        self.conv2 = nn.Conv2d(in_ch, out_ch, 3, padding=rates[0], dilation=rates[0])
        self.conv3 = nn.Conv2d(in_ch, out_ch, 3, padding=rates[1], dilation=rates[1])
        self.conv4 = nn.Conv2d(in_ch, out_ch, 3, padding=rates[2], dilation=rates[2])
        self.pool = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(in_ch, out_ch, 1),
            nn.Upsample(size=None, mode='bilinear', align_corners=False)
        )
        self.bn = nn.BatchNorm2d(out_ch * 5)
        self.relu = nn.ReLU(inplace=True)
        self.project = nn.Conv2d(out_ch * 5, out_ch, 1)
    def forward(self, x):
        x1 = self.conv1(x)
        x2 = self.conv2(x)
        x3 = self.conv3(x)
        x4 = self.conv4(x)
        x5 = self.pool(x)
        out = torch.cat([x1,x2,x3,x4,x5], dim=1)
        out = self.bn(out)
        out = self.relu(out)
        return self.project(out)

class DeepLabV3Plus(nn.Module):
    def __init__(self, n_classes=21, backbone='resnet101'):
        super().__init__()
        if backbone == 'resnet101':
            self.backbone = models.resnet101(weights=models.ResNet101_Weights.IMAGENET1K_V1)
        else:
            self.backbone = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
        self.low_level = nn.Sequential(*list(self.backbone.children())[:4])  # conv1+bn+relu+maxpool -> 64, 1/4
        self.high_level = nn.Sequential(*list(self.backbone.children())[5:-2]) # 直到layer4, 但替换为空洞版本？
        # 实际需要替换resnet的layer3和layer4为空洞卷积，这里简化
        self.aspp = ASPP(2048, 256)
        self.reduce = nn.Conv2d(256, 48, 1)  # 低层特征降维
        self.decoder = nn.Sequential(
            nn.Conv2d(304, 256, 3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, 3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, n_classes, 1)
        )
    def forward(self, x):
        low_feat = self.low_level(x)  # 1/4原始分辨率
        high_feat = self.high_level(low_feat)  # 1/32
        aspp_out = self.aspp(high_feat)
        up_aspp = nn.functional.interpolate(aspp_out, size=low_feat.shape[2:], mode='bilinear', align_corners=False)
        low_red = self.reduce(low_feat)
        concat = torch.cat([up_aspp, low_red], dim=1)
        out = self.decoder(concat)
        return nn.functional.interpolate(out, scale_factor=4, mode='bilinear', align_corners=False)

3.3 Mask R-CNN：两步法搞实例分割

基于Faster R-CNN，增加一个平行分支预测每个RoI的分割掩码（28x28）。关键改进：RoIAlign解决RoIPool量化偏差。两阶段：1）RPN生成候选框；2）框内做分类+回归+掩码。掩码分支用FCN，每个类别一个通道。TensorFlow官方实现更完整，这里用PyTorch的torchvision版本。

# model_maskrcnn.py
import torch
import torchvision
from torchvision.models.detection import maskrcnn_resnet50_fpn

def get_maskrcnn(num_classes=91, pretrained=True):
    model = maskrcnn_resnet50_fpn(weights='COCO_V1' if pretrained else None)
    # 替换分类头为自定义类别数
    in_features = model.roi_heads.box_predictor.cls_score.in_features
    model.roi_heads.box_predictor = torchvision.models.detection.faster_rcnn.FastRCNNPredictor(in_features, num_classes)
    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
    model.roi_heads.mask_predictor = torchvision.models.detection.mask_rcnn.MaskRCNNPredictor(in_features_mask, 256, num_classes)
    return model

四、完整训练流程（yml配置 + 命令）

统一使用Cityscapes数据集（19类别，2975训练，500验证），图像缩放至512x512。使用AdamW优化器，初始学习率1e-4，余弦退火，batch size 8（单卡RTX 3090 24GB）。下面是配置文件：

# config.yaml
dataset:
  name: Cityscapes
  root: /data/cityscapes
  image_size: [512, 512]
  num_classes: 19
training:
  batch_size: 8
  epochs: 100
  optimizer: AdamW
  lr: 0.0001
  scheduler: CosineAnnealingLR
  t_max: 100
  weight_decay: 0.0001
  loss:
    semantic: CrossEntropyLoss  # for UNet, DeepLab
    instance: [RPNLoss, MaskLoss, BoxLoss]  # for Mask R-CNN
augmentation:
  - RandomHorizontalFlip(p=0.5)
  - RandomCrop(512)

训练命令（bash）：

# 训练U-Net
python train.py --model unet --config config.yaml --epochs 100 --gpu 0

# 训练DeepLab
python train.py --model deeplab --backbone resnet101 --config config.yaml --epochs 100 --gpu 0

# 训练Mask R-CNN（官方detectron2风格）
python train_net.py --config-file ./configs/mask_rcnn_R_50_FPN_3x.yaml --num-gpus 1

数据标注示例（JSON格式）：

{
  "images": [{"id":1,"file_name":"munster_000001_000019_leftImg8bit.png","height":1024,"width":2048}],
  "annotations": [
    {"id":1001,"image_id":1,"category_id":1,"segmentation":[[x1,y1,x2,y2,...]],"area":1234,"bbox":[x,y,w,h],"iscrowd":0}
  ],
  "categories": [{"id":1,"name":"person"}]
}

五、效果数据：你的场景该选谁？

实验环境：Intel i9-13900K, 64GB RAM, NVIDIA RTX 3090, PyTorch 2.1.0, CUDA 12.1, Torchvision 0.16.0。数据：Cityscapes验证集。

模型	mIoU (语义)	AP@0.5 (实例)	推理速度 (ms/512x512)	参数量	训练时间 (epoch)
U-Net (ResNet34 backbone)	72.3%	N/A	28	14.3M	9.5 min
DeepLabV3+ (ResNet101)	81.4%	N/A	45	43.9M	18.2 min
Mask R-CNN (R50-FPN)	N/A (语义用单独head)	54.2%	120	47.5M	31 min

<注：AP指标为Cityscapes实例分割官方评价（SUV/车/人等），Mask R-CNN在验证集上AP@0.5=54.2%，与论文一致。U-Net和DeepLab计算mIoU不包含实例区分。>

结论：

• 纯语义分割且目标较小：U-Net又快又好（医学图像可到0.95 Dice）
• 语义分割但背景复杂/尺度变化大：DeepLab完胜，mIoU提升9个百分点
• 需要区分个体实例：别犹豫，上Mask R-CNN或YOLACT

六、避坑指南（我实际踩过的）

坑1：DeepLab主干空洞卷积替换不当，显存爆炸

用Torchvision的ResNet直接替换最后两层为空洞卷积时，忘记调整stride和dilation，导致输出特征图尺寸不对，而且反向传播显存占用飙升到20GB（512分辨率）。正确做法：用官方实现了的torchvision.ops或mobilenetv3。

坑2：Mask R-CNN训练时loss突然变成nan

原因是RPN的anchor生成与图像分辨率不匹配。Cityscapes原始分辨率1024x2048，我缩放到512x1024，但anchor大小还按COCO默认（32-512），导致大物体无匹配。解决方法：根据数据集统计重新聚类anchor size（用k-means）。

坑3：U-Net在混合精度（AMP）训练时loss震荡

使用PyTorch的GradScaler时，U-Net的跳连带来了梯度爆炸。建议：先用FP32稳定，再逐渐加梯度裁剪（max_norm=1.0）。

坑4：数据增强过猛导致类别不平衡

用RandomRotation(30)后，Cityscapes中“人”类别出现大量空白区域，被模型误判为“道路”。解决方案：只对前景区域做旋转，或使用弱增强。

坑5：评估时忘记设置model.eval()，mIoU虚高

BN和Dropout在推理时行为不同，有一次我拿模型验证没关dropout，mIoU从81%突然跳到89%，以为超参数调好了，后来才发现是dropout随机丢弃导致损失变低。切记加上model.eval()。

七、总结

没有万金油的分割网络，选型取决于任务：细节为王用U-Net，多尺度语义用DeepLab，实例区分用Mask R-CNN。别光看指标，把时间花在数据清洗和调参上，比反复改网络结构有效得多。我的GitHub仓库（链接省略）包含完整训练脚本和预处理pipeline，可以直接跑通Cityscapes。

<<>>