AE编码器的案例

首先，导入必要的库和模块：

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

接着，定义一个类来表示我们的自编码器：

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, 32),
            nn.ReLU()
        )
        
        self.decoder = nn.Sequential(
            nn.Linear(32, 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

在这里，我们定义了一个名为Autoencoder的类，它继承了nn.Module类。我们的自编码器将输入图像压缩成32维的向量，然后再将其解码回原始尺寸。

注意到我们使用了Sequential类来将神经网络层连接起来。这个类允许我们堆叠多个层，并将其作为单个模块处理。其中ReLU()函数是激活函数，它在每个隐藏层之后添加非线性变换。这些函数的目的是为了增加模型的表达能力。

对于解码器，我们使用了Sigmoid()函数作为输出层激活函数，将其转换到0到1之间的范围内。

接下来，定义一些超参数：

batch_size = 128
learning_rate = 1e-3
num_epochs = 10

然后，加载MNIST数据集并进行预处理：

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

在这里，我们使用了transforms库来定义一个变换，它将图像转换为张量，并归一化其像素值以使其范围在-1到1之间。我们还定义了一个DataLoader对象，用于批量读取数据。

接下来，初始化模型和优化器：

model = Autoencoder()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

在这里，我们使用了MSELoss作为损失函数，Adam优化器作为优化算法。

最后，训练模型：

for epoch in range(num_epochs):
    for data in train_loader:
        img, _ = data
        img = img.view(img.size(0), -1)
        recon = model(img)
        loss = criterion(recon, img)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print('Epoch:{}, Loss:{:.4f}'.format(epoch+1, loss.item()))

在这里，我们对于每个epoch，遍历训练数据集，并将每个batch的数据加载到模型中。首先将图像展平为一维张量，通过自编码器进行前向传播得到重构后的图像，然后计算重构误差并执行反向传播更新权重。

最后打印出当前epoch的损失值。

这就是一个使用PyTorch实现的简单自编码器示例。