pytorch实现autoencoder

关于autoencoder的内容简介可以参考这一篇博客，可以说写的是十分详细了https://sherlockliao.github.io/2017/06/24/vae/

盗图一张，自动编码器讲述的是对于一副输入的图像，或者是其他的信号，经过一系列操作，比如卷积，或者linear变换，变换得到一个向量，这个向量就叫做对这个图像的编码，这个过程就叫做encoder，对于一个特定的编码，经过一系列反卷积或者是线性变换，得到一副图像，这个过程叫做decoder，即解码。

然而自动编码器有什么用，看到上面的博客所写

所以现在自动编码器主要应用有两个方面，第一是数据去噪，第二是进行可视化降维。然而自动编码器还有着一个功能就是生成数据。

然而现在还没有用过这方面的应用，在这里需要着重说明一点的是autoencoder并不是聚类，因为虽然对于每一副图像都没有对应的label，但是autoencoder的任务并不是对图像进行分类啊。

就事论事，下面来分析一下一个大神写的关于autoencoder的代码，这里先给出github链接

先奉上代码

 # -*-coding: utf-8-*-

 __author__ = 'SherlockLiao'

 import torch

 import torchvision

 from torch import nn

 from torch.autograd import Variable

 from torch.utils.data import DataLoader

 from torchvision import transforms

 from torchvision.utils import save_image

 from torchvision.datasets import MNIST

 import os

 if not os.path.exists('./dc_img'):

     os.mkdir('./dc_img')

 def to_img(x):  # 将vector转换成矩阵

     x = 0.5 * (x + 1)

     x = x.clamp(0, 1)

     x = x.view(x.size(0), 1, 28, 28)

     return x

 num_epochs = 100

 batch_size = 128

 learning_rate = 1e-3

 img_transform = transforms.Compose([

     transforms.ToTensor(),

     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

 ])

 dataset = MNIST('./data', transform=img_transform)

 dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

 class autoencoder(nn.Module):

     def __init__(self):

         super(autoencoder, self).__init__()

         self.encoder = nn.Sequential(

             nn.Conv2d(1, 16, 3, stride=3, padding=1),  # b, 16, 10, 10

             nn.ReLU(True),

             nn.MaxPool2d(2, stride=2),  # b, 16, 5, 5

             nn.Conv2d(16, 8, 3, stride=2, padding=1),  # b, 8, 3, 3

             nn.ReLU(True),

             nn.MaxPool2d(2, stride=1)  # b, 8, 2, 2

         )

         self.decoder = nn.Sequential(

             nn.ConvTranspose2d(8, 16, 3, stride=2),  # b, 16, 5, 5

             nn.ReLU(True),

             nn.ConvTranspose2d(16, 8, 5, stride=3, padding=1),  # b, 8, 15, 15

             nn.ReLU(True),

             nn.ConvTranspose2d(8, 1, 2, stride=2, padding=1),  # b, 1, 28, 28

             nn.Tanh()  # 将输出值映射到-1~1之间

         )

     def forward(self, x):

         x = self.encoder(x)

         x = self.decoder(x)

         return x

 model = autoencoder().cuda()

 criterion = nn.MSELoss()

 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate,

                              weight_decay=1e-5)

 for epoch in range(num_epochs):

     for data in dataloader:

         img, _ = data  # img是一个b*channel*width*height的矩阵

         img = Variable(img).cuda()

         # ===================forward=====================

         output = model(img)

         a = img.data.cpu().numpy()

         b = output.data.cpu().numpy()

         loss = criterion(output, img)

         # ===================backward====================

         optimizer.zero_grad()

         loss.backward()

         optimizer.step()

     # ===================log========================

     print('epoch [{}/{}], loss:{:.4f}'

           .format(epoch+1, num_epochs, loss.data[0]))

     if epoch % 10 == 0:

         pic = to_img(output.cpu().data)  # 将decoder的输出保存成图像

         save_image(pic, './dc_img/image_{}.png'.format(epoch))

 torch.save(model.state_dict(), './conv_autoencoder.pth')