第14课：图像分割基础

📖 本课概述

图像分割是像素级的视觉理解——对每个像素分类。本课从语义分割到实例分割，理解U-Net等经典架构。

🎯 一、分割问题分类

🏗️ 二、U-Net架构

2.1 编码器-解码器结构

2.2 转置卷积

2.3 PyTorch实现U-Net

import torch
import torch.nn as nn

# U-Net实现
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(),
            nn.Conv2d(out_ch, out_ch, 3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(),
        )
    def forward(self, x):
        return self.conv(x)

class UNet(nn.Module):
    def __init__(self, in_ch=1, out_ch=1):
        super().__init__()
        # 编码器
        self.enc1 = DoubleConv(in_ch, 64)
        self.enc2 = DoubleConv(64, 128)
        self.enc3 = DoubleConv(128, 256)
        self.pool = nn.MaxPool2d(2)
        
        # 瓶颈层
        self.bottleneck = DoubleConv(256, 512)
        
        # 解码器
        self.up3 = nn.ConvTranspose2d(512, 256, 2, stride=2)
        self.dec3 = DoubleConv(512, 256)
        self.up2 = nn.ConvTranspose2d(256, 128, 2, stride=2)
        self.dec2 = DoubleConv(256, 128)
        self.up1 = nn.ConvTranspose2d(128, 64, 2, stride=2)
        self.dec1 = DoubleConv(128, 64)
        
        self.final = nn.Conv2d(64, out_ch, 1)
    
    def forward(self, x):
        # 编码
        e1 = self.enc1(x)      # 64
        e2 = self.enc2(self.pool(e1))  # 128
        e3 = self.enc3(self.pool(e2))  # 256
        
        # 瓶颈
        b = self.bottleneck(self.pool(e3))  # 512
        
        # 解码 + 跳跃连接
        d3 = self.up3(b)
        d3 = self.dec3(torch.cat([d3, e3], dim=1))
        d2 = self.up2(d3)
        d2 = self.dec2(torch.cat([d2, e2], dim=1))
        d1 = self.up1(d2)
        d1 = self.dec1(torch.cat([d1, e1], dim=1))
        
        return self.final(d1)

# 测试
model = UNet(in_ch=1, out_ch=2)
x = torch.randn(2, 1, 64, 64)
out = model(x)
params = sum(p.numel() for p in model.parameters())
print(f"U-Net: 输入{list(x.shape)} → 输出{list(out.shape)}, 参数量={params:,}")

# 转置卷积验证
print("\n=== 转置卷积尺寸变化 ===")
x_small = torch.randn(1, 1, 4, 4)
conv_trans = nn.ConvTranspose2d(1, 1, 3, stride=2, padding=1)
out_up = conv_trans(x_small)
print(f"转置卷积(4×4→{out_up.shape[-2]}×{out_up.shape[-1]})")

# 不同上采样方法对比
print("\n=== 上采样方法对比 ===")
x_test = torch.randn(1, 64, 4, 4)
methods = {
    "最近邻插值": nn.Upsample(scale_factor=2, mode='nearest'),
    "双线性插值": nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),
    "转置卷积": nn.ConvTranspose2d(64, 64, 2, stride=2),
}
for name, method in methods.items():
    out = method(x_test)
    params = sum(p.numel() for p in method.parameters()) if hasattr(method, 'parameters') else 0
    print(f"{name}: {list(x_test.shape)} → {list(out.shape)}, 参数量={params:,}")

# 分割损失：Dice Loss
def dice_loss(pred, target, smooth=1.0):
    pred = torch.sigmoid(pred)
    intersection = (pred * target).sum()
    return 1 - (2 * intersection + smooth) / (pred.sum() + target.sum() + smooth)

pred = torch.randn(1, 1, 8, 8)
target = torch.randint(0, 2, (1, 1, 8, 8)).float()
print(f"\nDice Loss: {dice_loss(pred, target).item():.4f}")
print(f"BCE Loss: {nn.BCEWithLogitsLoss()(pred, target).item():.4f}")

🔬 深入拓展

核心要点回顾

本课的核心知识点构成了CNN学习的重要一环。让我们从更高维度审视这些知识之间的关系：

• 理论层面：理解数学原理是正确应用的前提，每个公式背后都有直觉
• 工程层面：PyTorch提供了高效实现，但理解底层原理才能正确调试
• 实践层面：没有银弹，不同场景需要不同的策略组合

常见陷阱与最佳实践

与前后课程的联系

深度学习是一个整体——每一课的知识都不是孤立的：

• 优化器（第5课）的选择影响正则化（第6课）的效果
• 初始化（第7课）决定了训练能否开始
• CNN（第8-14课）的成功依赖训练技巧（第22-28课）
• Transformer（第20-21课）结合了注意力和位置编码
• 实战项目（第29-35课）综合运用所有知识

📖 延伸阅读

📝 练习

💡 图像分割实践

分割任务选择

• 语义分割：U-Net / DeepLab
• 实例分割：Mask R-CNN / SOLO
• 全景分割：Panoptic FPN
• 医学分割：U-Net++ / Attention U-Net

常见错误与解决方案

性能优化建议

🔬 深度拓展：从理论到实践

核心概念网络

理解本课内容需要将其置于更大的知识网络中。每个核心概念都不是孤立的，它们相互关联、相互支撑：

• 数学基础：线性代数、微积分、概率论是理解所有深度学习算法的根基
• 计算基础：自动微分、GPU并行计算让理论变为现实
• 工程基础：数据处理、模型设计、训练技巧的有机结合
• 领域知识：CV、NLP、语音等领域的先验知识指导模型设计

关键洞察与直觉

建立正确的直觉比记住公式更重要：

与其他课程的关联

本课作为CNN阶段的核心内容，与前后课程紧密关联：

面试常见问题

进阶学习路径

掌握本课内容后，可以通过以下方式继续深入：

• 阅读本课相关的一手论文，理解原始动机和推导
• 复现论文的实验结果，验证自己的理解
• 尝试改进方法，思考为什么现有方法有局限
• 在真实项目或Kaggle竞赛中应用
• 关注该方向的最新进展（arXiv、顶级会议）