PyTorch实现自编码器

客官°小女子只卖身不卖艺 2023-09-30 22:23 48阅读 0赞

以下是一个使用PyTorch实现自编码器的示例代码，该代码包括三个自编码器和一些辅助函数，用于训练和测试自编码器。

案例1

  1. import torch
  2. import torch.nn as nn
  3. import torch.optim as optim
  4. import torchvision.transforms as transforms
  5. import torchvision.datasets as datasets
  6. import numpy as np
  7. import matplotlib.pyplot as plt
  9. # Define the Stacked Autoencoder class
  10. class StackedAutoencoder(nn.Module):
  11.     def __init__(self, input_dim, hidden_dims):
  12.         super(StackedAutoencoder, self).__init__()
  13.         self.input_dim = input_dim
  14.         self.hidden_dims = hidden_dims
  16.         # Define the encoder layers
  17.         self.encoder1 = nn.Linear(input_dim, hidden_dims[0])
  18.         self.encoder2 = nn.Linear(hidden_dims[0], hidden_dims[1])
  19.         self.encoder3 = nn.Linear(hidden_dims[1], hidden_dims[2])
  21.         # Define the decoder layers
  22.         self.decoder3 = nn.Linear(hidden_dims[2], hidden_dims[1])
  23.         self.decoder2 = nn.Linear(hidden_dims[1], hidden_dims[0])
  24.         self.decoder1 = nn.Linear(hidden_dims[0], input_dim)
  26.         # Define the activation function
  27.         self.activation = nn.ReLU()
  29.     def encoder(self, x):
  30.         z1 = self.activation(self.encoder1(x))
  31.         z2 = self.activation(self.encoder2(z1))
  32.         z3 = self.activation(self.encoder3(z2))
  33.         return z3
  35.     def decoder(self, z):
  36.         xhat3 = self.activation(self.decoder3(z))
  37.         xhat2 = self.activation(self.decoder2(xhat3))
  38.         xhat1 = self.decoder1(xhat2)
  39.         return xhat1
  41.     def forward(self, x):
  42.         z = self.encoder(x)
  43.         xhat = self.decoder(z)
  44.         return xhat
  46.     def get_encoder_output(self, x):
  47.         return self.encoder(x)
  49. # Define the training function
  50. def train(model, train_loader, num_epochs, learning_rate):
  51.     # Define the loss function and optimizer
  52.     criterion = nn.MSELoss()
  53.     optimizer = optim.Adam(model.parameters(), lr=learning_rate)
  55.     # Train the model
  56.     for epoch in range(num_epochs):
  57.         for data in train_loader:
  58.             # Get the input data and target data
  59.             inputs, targets = data
  60.             inputs, targets = inputs.view(-1, 28*28), targets.view(-1, 28*28)
  62.             # Zero the gradients
  63.             optimizer.zero_grad()
  65.             # Forward pass
  66.             outputs = model(inputs)
  67.             loss = criterion(outputs, targets)
  69.             # Backward pass and optimization
  70.             loss.backward()
  71.             optimizer.step()
  73.         # Print the loss after each epoch
  74.         print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
  76. # Define the test function
  77. def test(model, test_loader):
  78.     # Define the loss function
  79.     criterion = nn.MSELoss()
  81.     # Evaluate the model
  82.     test_loss = 0
  83.     with torch.no_grad():
  84.         for data in test_loader:
  85.             # Get the input data and target data
  86.             inputs, targets = data
  87.             inputs, targets = inputs.view(-1, 28*28), targets.view(-1, 28*28)
  89.             # Forward pass
  90.             outputs = model(inputs)
  91.             test_loss += criterion(outputs, targets).item()
  93.     # Print the average test loss
  94.     test_loss /= len(test_loader.dataset)
  95.     print('Average Test Loss: {:.4f}'.format(test_loss))

主程序

  1. # Define the main function
  2. def main():
  3.     # Set the device
  4.     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  6.     # Set the hyperparameters
  7.     input_dim = 28*28
  8.     hidden_dims = [256, 128, 64]
  9.     num_epochs = 10
  10.     batch_size = 128
  11.     learning_rate = 0.001
  13.     # Download the MNIST dataset and create data loaders
  14.     train_dataset = datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
  15.     test_dataset = datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor(), download=True)
  16.     train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
  17.     test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
  19.     # Create the Stacked Autoencoder model and move it to the device
  20.     model = StackedAutoencoder(input_dim, hidden_dims).to(device)
  22.     # Train the model
  23.     train(model, train_loader, num_epochs, learning_rate)
  25.     # Test the model
  26.     test(model, test_loader)
  28.     # Generate a random image and its reconstruction
  29.     with torch.no_grad():
  30.         z = torch.randn(1, hidden_dims[-1]).to(device)
  31.         xhat = model.decoder(z)
  32.         xhat = xhat.view(28, 28).cpu().numpy()
  33.         plt.imshow(xhat, cmap='gray')
  34.         plt.show()
  36. if __name__ == '__main__':
  37.     main()

在 main() 函数中，首先设置了设备，然后定义了超参数，接着下载 MNIST 数据集并创建数据加载器。然后创建了自编码器模型，并将其移动到设备上。接下来调用 train() 函数进行训练，然后调用 test() 函数进行测试。最后生成一个随机图像并进行重构，然后显示出来。

在 train() 函数中，定义了损失函数和优化器，然后对模型进行了训练。在 test() 函数中，定义了损失函数，并对模型进行了测试。

在 test() 函数中，定义了损失函数，并对模型进行了测试。测试过程与训练过程类似，但是不需要进行梯度更新。最后返回测试损失的平均值。

案例2

  1. import torch
  2. import torch.nn as nn
  3. import torch.optim as optim
  4. import torchvision
  5. import torchvision.transforms as transforms
  7. # 数据预处理
  8. transform = transforms.Compose([
  9.     transforms.ToTensor(),
  10.     transforms.Normalize((0.5,), (0.5,))
  11. ])
  13. # 加载MNIST数据集
  14. trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
  15. trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
  17. # 定义自编码器模型
  18. class StackedAutoencoder(nn.Module):
  19.     def __init__(self, input_dim, hidden_dims):
  20.         super(StackedAutoencoder, self).__init__()
  21.         self.encoder = nn.Sequential(
  22.             nn.Linear(input_dim, hidden_dims[0]),
  23.             nn.ReLU()
  24.         )
  25.         self.decoder = nn.Sequential(
  26.             nn.Linear(hidden_dims[0], input_dim),
  27.             nn.ReLU()
  28.         )
  30.     def forward(self, x):
  31.         x = self.encoder(x)
  32.         x = self.decoder(x)
  33.         return x
  35. # 训练自编码器
  36. input_dim = 28 * 28  # MNIST图像尺寸为28x28
  37. hidden_dims = [256, 128]  # 隐藏层维度
  39. model = StackedAutoencoder(input_dim, hidden_dims)
  40. criterion = nn.MSELoss()
  41. optimizer = optim.Adam(model.parameters(), lr=0.001)
  43. num_epochs = 10
  45. for epoch in range(num_epochs):
  46.     running_loss = 0.0
  47.     for images, _ in trainloader:
  48.         images = images.view(images.size(0), -1)
  49.         optimizer.zero_grad()
  50.         outputs = model(images)
  51.         loss = criterion(outputs, images)
  52.         loss.backward()
  53.         optimizer.step()
  54.         running_loss += loss.item()
  56.     epoch_loss = running_loss / len(trainloader)
  57.     print(f"Epoch {
  58.       epoch+1}/{
  59.       num_epochs}, Loss: {
  60.       epoch_loss:.4f}")
  62. print("Training finished!")
  64. # 使用自编码器进行图像重建
  65. testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
  66. testloader = torch.utils.data.DataLoader(testset, batch_size=10, shuffle=False)
  68. dataiter = iter(testloader)
  69. images, labels = dataiter.next()
  70. images = images.view(images.size(0), -1)
  71. outputs = model(images)
  73. # 可视化原始图像和重建图像
  74. import matplotlib.pyplot as plt
  76. def imshow(img):
  77.     img = img / 2 + 0.5  # 反归一化
  78.     npimg = img.numpy()
  79.     plt.imshow(np.transpose(npimg, (1, 2, 0)))
  80.     plt.axis('off')
  81.     plt.show()
  83. # 显示原始图像
  84. imshow(torchvision.utils.make_grid(images.view(-1, 1, 28, 28)))
  85. # 显示重建图像
  86. imshow(torchvision.utils.make_grid(outputs.view(-1, 1, 28, 28)))

这个案例实现了一个简单的两层自编码器，用于对MNIST数据集中的手写数字图像进行重建。首先定义了一个StackedAutoencoder类，它包含一个编码器和一个解码器，其中编码器是一个包含ReLU激活函数的全连接层序列，解码器也是一个包含ReLU激活函数的全连接层序列。然后，通过使用MSE损失函数和Adam优化器对模型进行训练。在训练过程中，将图像展平为784维的向量，并将其输入到模型中，然后计算重建图像与原始图像之间的损失，并进行反向传播和参数更新。最后，使用训练好的模型对一批测试图像进行重建，并将原始图像和重建图像可视化。

自编码器可以包含更多的隐藏层，更复杂的结构和更多的训练步骤，以更好地学习数据的表示。此外，还可以尝试在编码器和解码器之间添加dropout层、使用不同的激活函数等来改进模型的性能。

发表评论

表情：
评论列表 （有 0 条评论，48人围观）

还没有评论，来说两句吧...

相关阅读

    相关 PyTorch实现联邦学习堆叠自编码器

    联邦学习是一种用于训练分布在不同设备或地点的模型的技术，其中数据分布在不同的设备上，且不会离开设备。每个设备只训练其本地数据的模型，并将更新的模型参数传递给服务器，服务器对这些

    向右看齐向右看齐/ 0 赞/ 82 阅读

    相关 自编码器

    无监督学习介绍 Markdown Code 内容简介 目前许多有监督学习算法，如 SVM，DNN 或是 boosting，决策树等，都在工业界分类或决策任务上取得了

    缺乏、安全感缺乏、安全感/ 0 赞/ 452 阅读