自动编码器pytorch代码

以下是一个简单的PyTorch自动编码器代码：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义自动编码器模型
class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(28*28, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 12),
            nn.ReLU(),
            nn.Linear(12, 3)
        )
        self.decoder = nn.Sequential(
            nn.Linear(3, 12),
            nn.ReLU(),
            nn.Linear(12, 64),
            nn.ReLU(),
            nn.Linear(64, 128),
            nn.ReLU(),
            nn.Linear(128, 28*28),
            nn.Sigmoid()
        )
        
    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

# 加载数据
train_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('../data', train=True, download=True,
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))
                               ])),
    batch_size=32, shuffle=True)

# 定义模型、优化器、损失函数
autoencoder = Autoencoder()
optimizer = optim.Adam(autoencoder.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 训练模型
for epoch in range(10):
    for data in train_loader:
        x, _ = data
        x = x.view(-1, 28*28)
        optimizer.zero_grad()
        output = autoencoder(x)
        loss = criterion(output, x)
        loss.backward()
        optimizer.step()
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, loss.item()))

# 测试模型
with torch.no_grad():
    for data in train_loader:
        x, _ = data
        x = x.view(-1, 28*28)
        output = autoencoder(x)
        break

# 可视化结果
import matplotlib.pyplot as plt
fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(25,4))
for i in range(10):
    axes[0,i].imshow(x[i].reshape(28,28), cmap='gray')
    axes[1,i].imshow(output[i].reshape(28,28), cmap='gray')
plt.show()

这个自动编码器模型使用MNIST数据集进行训练和测试，其中包含了一个三层的编码器和一个三层的解码器。模型的编码器将MNIST图像的28x28像素展平为784维的向量，然后通过128、64和12个隐藏单元的全连接层进行编码，最终输出3维的编码向量。模型的解码器将这个3维的编码向量通过12、64和128个隐藏单元的全连接层进行解码，最终输出一个与输入图像相同大小的图像。

训练过程中，模型的目标是最小化重构误差（即输入图像和输出图像之间的均方误差）。在每个训练周期结束时，模型会在MNIST训练集的一个小批量上计算重构误差，并输出训练周期的平均误差。在测试过程中，模型会将MNIST训练集的一个小批量输入自动编码器，并输出重构图像。这些图像可以用来可视化自动编码器的性能。