基于PyTorch的AE自编码器实战：从数据降维到异常检测

1次阅读

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

在数据处理和特征提取领域，传统方法如 PCA（主成分分析）虽然简单有效，但存在明显的局限性。PCA 是一种线性降维方法，无法捕捉数据中的非线性关系，这在复杂的现实数据中往往导致信息丢失。此外，PCA 在异常检测中的应用也较为有限，主要依赖重构误差的统计分布。

相比之下，自编码器（Autoencoder, AE）作为一种非线性降维方法，能够通过深度神经网络学习数据的潜在表示。AE 的优势主要体现在：

能够捕捉数据中的非线性特征
在无监督学习中表现出色
重构误差可以很好地用于异常检测
潜在空间表示更具解释性

一个标准的 AE 包含两个主要部分：编码器（Encoder）和解码器（Decoder）。编码器将输入数据压缩到潜在空间（bottleneck layer），解码器则尝试从潜在表示重构原始输入。

在 PyTorch 中实现 AE 时，我们需要考虑以下设计要点：

输入层大小应与原始数据维度匹配
隐藏层通常采用逐层递减 / 递增的结构
瓶颈层大小决定了降维后的特征维度
激活函数的选择（ReLU 常用于隐藏层，Sigmoid/Tanh 用于输出层）

AE 的训练目标是最小化输入和输出之间的差异，常用的损失函数包括：

均方误差（MSE）：适用于连续值数据
二元交叉熵（BCE）：适用于二值化数据（如 MNIST）
对于更复杂的变体（如 VAE），还需要考虑 KL 散度

Adam 优化器通常是训练 AE 的良好选择，学习率一般设置在 0.001 左右。训练过程中可能需要调整学习率调度器（如 ReduceLROnPlateau）来避免震荡。

以下是完整的 PyTorch 实现代码，包含详细的注释：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

# 定义自编码器结构
class Autoencoder(nn.Module):
    def __init__(self, input_dim=784, latent_dim=32):
        super(Autoencoder, self).__init__()
        # 编码器
        self.encoder = nn.Sequential(nn.Linear(input_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, latent_dim)  # 瓶颈层
        )
        # 解码器
        self.decoder = nn.Sequential(nn.Linear(latent_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Linear(256, input_dim),
            nn.Sigmoid()  # 输出在 0 - 1 之间)

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

# 数据准备
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 模型初始化
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Autoencoder().to(device)
criterion = nn.BCELoss()  # 适用于 MNIST 这种二值化图像
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练循环
num_epochs = 20
for epoch in range(num_epochs):
    for data in train_loader:
        img, _ = data
        img = img.view(img.size(0), -1).to(device)  # 展平图像

        # 前向传播
        output = model(img)
        loss = criterion(output, img)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 可视化结果
with torch.no_grad():
    test_img, _ = next(iter(train_loader))
    test_img = test_img.view(test_img.size(0), -1).to(device)
    reconstructed = model(test_img)

    # 显示原始和重构图像
    fig, axes = plt.subplots(2, 5, figsize=(10, 4))
    for i in range(5):
        axes[0, i].imshow(test_img[i].cpu().view(28, 28), cmap='gray')
        axes[1, i].imshow(reconstructed[i].cpu().view(28, 28), cmap='gray')
    plt.show()

通过实验不同深度的网络结构，我们发现：