CAE卷积自编码器模型入门指南：从理论到PyTorch实战

1次阅读

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

传统全连接自编码器（AE）处理图像时会遇到两个致命问题：

参数爆炸：假设处理 28×28 的 MNIST 图像，仅输入层到第一隐藏层的全连接权重就需 784×n 个参数（n 为隐藏层神经元数），当图像尺寸增大时（如 256×256），参数量会呈平方级增长
空间信息丢失：全连接层将二维图像展平为一维向量，破坏了像素间的空间关联性，导致重建图像模糊

特性	普通 AE	CAE	VAE
参数量	极高	中等	中等
空间特征保留	无	优秀	良好
训练速度	慢	快	中等
生成能力	无	弱	强
主要用途	降维	特征提取	生成模型

卷积层 ：使用 Conv2d 提取局部特征，例如nn.Conv2d(1, 16, 3, stride=1, padding=1) 表示：
输入通道 1（灰度图）
输出通道 16
3×3 卷积核
保持尺寸不变（padding=1）
激活函数：ReLU 引入非线性，公式为 $f(x)=max(0,x)$
池化层 ：MaxPool2d(2) 进行下采样，将特征图尺寸减半，例如 28×28 → 14×14

关键点在于使用转置卷积（ConvTranspose2d）实现上采样：

nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1)表示：
输入通道 16
输出通道 1（重建灰度图）
通过 stride= 2 实现尺寸翻倍（14×14 → 28×28）

假设输入为 MNIST 图像（1×28×28）：

# 编码过程
conv1 = nn.Conv2d(1, 16, 3, padding=1)  # 1×28×28 → 16×28×28
pool = nn.MaxPool2d(2)                  # 16×28×28 → 16×14×14

# 解码过程
deconv = nn.ConvTranspose2d(16, 1, 3, stride=2, 
                          padding=1, output_padding=1)  # 16×14×14 → 1×28×28

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

class CAE(nn.Module):
    def __init__(self):
        super(CAE, self).__init__()
        # 编码器
        self.encoder = nn.Sequential(nn.Conv2d(1, 16, 3, stride=1, padding=1),  # 16×28×28
            nn.ReLU(),
            nn.MaxPool2d(2),                          # 16×14×14

            nn.Conv2d(16, 8, 3, stride=1, padding=1), # 8×14×14
            nn.ReLU(),
            nn.MaxPool2d(2)                           # 8×7×7
        )

        # 解码器
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(8, 8, 3, stride=2,     # 8×7×7 → 8×13×13
                             padding=1, output_padding=1),
            nn.ReLU(),

            nn.ConvTranspose2d(8, 16, 3, stride=2,    # 8×13×13 → 16×26×26
                              padding=1, output_padding=1),
            nn.ReLU(),

            nn.Conv2d(16, 1, 3, padding=1),          # 16×26×26 → 1×26×26
            nn.Sigmoid()  # 像素值压缩到[0,1]
        )

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

# 训练配置
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))  # MNIST 像素值归一化到[-1,1]
])

train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_data, batch_size=128, shuffle=True)

model = CAE()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

激活函数选择：
解码器最后一层使用 Sigmoid 而非 ReLU，防止像素值被截断在[0,∞)
中间层推荐 ReLU 加速收敛
损失函数陷阱：
使用 BCELoss 时必须搭配 Sigmoid 输出层
MSE Loss 对像素级重建更稳定

特征可视化技巧：

# 查看第 1 层卷积核权重
first_conv_weights = model.encoder[0].weight.data.cpu().numpy()

# 可视化中间特征图
with torch.no_grad():
    features = model.encoder(input_img)
    plt.imshow(features[0, 0].cpu().numpy())  # 显示第 1 个通道

维度对齐秘诀：
使用 output_padding 解决转置卷积尺寸不匹配问题
通过公式计算输出尺寸：$H_{out} = (H_{in}-1)×stride – 2×padding + kernel_size + output_padding$
训练技巧：
初始学习率建议 1e- 3 到 1e-4
批量大小不宜过小（≥64）
数据预处理：
必须做归一化（如缩放到 [0,1] 或[-1,1]）
对 MNIST 建议使用transforms.Normalize((0.5,), (0.5,))