AE编码器的案例

柔光的暖阳◎ 2023-09-30 21:57 18阅读 0赞

#### AE编码器的案例 ####

下面是一个使用PyTorch实现自编码器（AE）的示例代码。这个自编码器有两个隐藏层，分别是128和64。

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

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实现的简单自编码器示例。