t-SNE与AE对MNIST可视化

王 茂南
王 茂南
王 茂南
2818
文章
75
评论
2020年7月2日07:02:43
评论1 6445字阅读21分29秒
摘要本文介绍关于使用t-SNE进行可视化, 会使用MNIST作为测试数据集. 本文会主要分为两个部分, 首先使用AE对数据进行降维, 降到24维, 接着使用t-SNE对数据进一步降维, 降低到2维, 并进行可视化.

简介

本文介绍关于使用t-SNE进行可视化, 会使用MNIST作为测试数据集. 因为t-SNE的计算速度比较慢, 所以通常的做法是:

  • 首先使用AutoEncoder进行降维, 降低到较低的维度 (例如30维)
  • 接着对上面的数据使用t-SNE进行进一步的降维, 来进行可视化.

在这一部分, 我们会首先使用AutoEncoder将MNIST图片降到24维, 接着使用t-SNE进一步进行降维, 并进行可视化.

于是, 这里实验可以分为两个大部分, 分别是训练AE和使用t-SNE进行降维可视化, 下面我们来分开进行介绍.

参考资料

 

训练AutoEncoder

首先我们将MNIST图片使用AE来进行降维, 关于完整的代码还是可以参考Github的链接.

加载数据集

  1. batch_size = 100
  3. # MNIST dataset
  4. train_dataset = torchvision.datasets.MNIST(root='./data',
  5.                                            train=True,
  6.                                            transform=transforms.ToTensor(),
  7.                                            download=True)
  8. test_dataset = torchvision.datasets.MNIST(root='./data',
  9.                                           train=False,
  10.                                           transform=transforms.ToTensor())
  11. # Data loader
  12. train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
  13.                                            batch_size=batch_size,
  14.                                            shuffle=True)
  15. test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
  16.                                           batch_size=batch_size,
  17.                                           shuffle=False)

 

定义网络, 定义AutoEncoder

这里我们使用卷积网络来组成encode, 使用逆卷积来组成decode.

  1. # 定义网络
  2. class DeepAutoEncoder(nn.Module):
  3.     def __init__(self):
  4.         super(DeepAutoEncoder, self).__init__()
  5.         self.encoder = nn.Sequential(
  6.             nn.Conv2d(in_channels=1, out_channels=3, kernel_size=2, stride=1, padding=0, bias=False),
  7.             nn.BatchNorm2d(3),
  8.             nn.LeakyReLU(0.2, inplace=True),
  10.             nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=2, padding=0, bias=False),
  11.             nn.BatchNorm2d(6),
  12.             nn.LeakyReLU(0.2, inplace=True),
  14.             nn.Conv2d(in_channels=6, out_channels=6, kernel_size=3, stride=2, padding=0, bias=False),
  15.             nn.BatchNorm2d(6),
  16.             nn.LeakyReLU(0.2, inplace=True),
  18.             nn.Conv2d(in_channels=6, out_channels=6, kernel_size=4, stride=2, padding=0, bias=False),
  19.             nn.BatchNorm2d(6),
  20.             nn.LeakyReLU(0.2, inplace=True),
  21.         ) # encoder可以将图片大小转换为 1*28*28 -> 6*2*2
  23.         self.decoder = nn.Sequential(
  24.             nn.ConvTranspose2d(in_channels=6, out_channels=6, kernel_size=4, stride=2, bias=False), # 1->4
  25.             nn.BatchNorm2d(6),
  26.             nn.ReLU(True),
  28.             nn.ConvTranspose2d(in_channels=6, out_channels=6, kernel_size=3, stride=2, bias=False), # 1->4
  29.             nn.BatchNorm2d(6),
  30.             nn.ReLU(True),
  32.             nn.ConvTranspose2d(in_channels=6, out_channels=3, kernel_size=3, stride=2, bias=False), # 4 -> 10
  33.             nn.BatchNorm2d(3),
  34.             nn.ReLU(True),
  36.             nn.ConvTranspose2d(in_channels=3, out_channels=1, kernel_size=2, stride=1, bias=False), # 10 -> 22
  37.             nn.BatchNorm2d(1),
  38.             # nn.Tanh()
  39.         ) # decoder可以将图片大小转换为 6*2*2 -> 1*28*28
  41.     def forward(self, x):
  42.         x = self.encoder(x)
  43.         # print(x.shape)
  44.         x = self.decoder(x)
  45.         return x

在上面设计网络的时候, 我们可以简单使用数据集进行测试. 我们可以查看输出的大小.

  1. AE = DeepAutoEncoder().to(device) # 定义分类器
  3. # 进行测试
  4. for i, (datas, labels) in enumerate(train_loader):
  5.     datas = datas.to(device)
  6.     x = AE(datas)
  7.     print(x.shape)
  8.     break
  10. """
  11. torch.Size([100, 1, 28, 28])
  12. """

 

模型的训练

在定义模型完毕之后, 就是模型的训练. 我们这里使用L1 Loss进行训练, 使用Adam优化器.

  1. # ----------
  2. # 初始化网络
  3. # ----------
  4. AE = DeepAutoEncoder().to(device) # 定义分类器
  5. # ------------
  6. # 定义损失函数
  7. # ------------
  8. criterion = nn.L1Loss()
  9. # -----------------------
  10. # 定义损失函数和优化器
  11. # -----------------------
  12. learning_rate = 0.0005
  13. optimizer = torch.optim.Adam(AE.parameters(), lr=learning_rate)
  15. lossList = []
  17. # ---------
  18. # 开始训练
  19. # ---------
  20. num_epochs = 20
  21. total_step = len(train_loader) # 依次epoch的步骤
  22. # 开始训练
  23. for epoch in range(num_epochs):
  24.     totalLoss = 0 # 总的误差
  25.     for i, (images, _) in enumerate(train_loader):
  26.         batch_size = images.size(0)
  27.         images = images.to(device)
  28.         # ---------------------
  29.         # 开始训练discriminator
  30.         # ---------------------
  31.         AE.train()
  32.         # 首先计算真实的图片
  33.         fake_image = AE(images) # 计算重构之后的内容
  34.         loss = criterion(images, fake_image) # 计算loss
  35.         optimizer.zero_grad() # 优化器梯度都要清0
  36.         loss.backward() # 反向传播
  37.         optimizer.step() # 进行优化
  39.         totalLoss = totalLoss + loss.item()
  40.         # ---------
  41.         # 打印结果
  42.         # ---------
  43.         if (i+2) % 280 == 0:
  44.             t = datetime.now() #获取现在的时间
  45.             print('Time {}, Epoch [{}/{}], Step [{}/{}], loss:{:.4f}'.format(t, epoch, num_epochs, i+1, total_step, totalLoss/(i+1)))
  46.     lossList.append(totalLoss/(i+1))

之后绘制loss的变化曲线.

  1. # 绘制loss的变化
  2. fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(13,7))
  3. axes.plot(lossList, 'k--')
t-SNE与AE对MNIST可视化

 

重构图像查看

接着我们使用上面训练的AE来进行图像的重构, 看一下最后output的结果. 首先我们选出16张测试的图片, 并查看原始图片.

  1. # 查看重构的图像
  2. T_images = torch.stack(([train_dataset[i][0] for i in range(16)]))
  3. show(make_grid(T_images, nrow=4, padding=0, normalize=True, range=None, scale_each=False, pad_value=0))
t-SNE与AE对MNIST可视化

接着我们同样对上面的16张图片, 将他们作为input, 来查看output.

  1. # 查看重构的图片
  2. fake_image = AE(T_images.to(device))
  3. show(make_grid(fake_image.cpu().detach(), nrow=4, padding=0, normalize=True, range=None, scale_each=False, pad_value=0))
t-SNE与AE对MNIST可视化

 

使用t-SNE降维可视化

在训练好上面的encode之后, 我们使用t-SNE对encode的输出进行可视化.

  1. from sklearn.manifold import TSNE

 

提取数据

因为这里需要接收Numpy的数据, 所以我们需要首先将数据从trainloader中提取出来.

  1. # 进行测试, 生成测试数据
  2. for i, (datas, labels) in enumerate(test_loader):
  3.     batch_size = images.size(0)
  4.     datas = datas.to(device)
  5.     x = AE.encoder(datas)
  6.     x = x.cpu().detach().numpy().reshape(batch_size, -1)
  7.     if i == 0:
  8.         featureList = x # 保存encode之后的特征
  9.         labelsList = labels # 保存对应的label
  10.     else:
  11.         featureList = np.append(featureList, x, axis=0)
  12.         labelsList = np.append(labelsList, labels, axis=0)
  13.     # if i == 3:
  14.     #     break
  16. print(featureList.shape, labelsList.shape)
  17. """
  18. ((10000, 24), (10000,))
  19. """

 

使用t-SNE降维可视化

接着我们对上面encode之后的结果使用t-SNE进行降维

  1. # 降到2维
  2. x_encode = TSNE(n_components=2).fit_transform(featureList) # 接着使用tSNE进行降维
  3. print(x_encode.shape)
  4. """
  5. (10000, 2)
  6. """

最后对上面得到的结果进行可视化即可:

  1. # 进行可视化
  2. cmap = plt.get_cmap('plasma',10) # 数字与颜色的转换
  5. # 获得可视化数据
  6. v_x = x_encode
  7. v_y = labelsList
  9. # 进行可视化
  10. fig = plt.figure(figsize=(14,8))
  11. ax = fig.add_subplot(1,1,1)
  13. classes = [0,1,2,3,4,5,6,7,8,9]
  15. for key in classes:
  16.     ix = np.where(v_y==key)
  17.     ax.scatter(v_x[ix][:,0], v_x[ix][:,1], color=cmap(key), label=key)
  18.     ax.text(np.mean(v_x[ix][:,0]), np.mean(v_x[ix][:,1]), key, fontsize=18, bbox=dict(facecolor='white', alpha=0.5))
  20. ax.legend()
  21. plt.show()

最终的结果如下所示:

t-SNE与AE对MNIST可视化

 

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南
  • 本文由 发表于 2020年7月2日07:02:43
  • 转载请务必保留本文链接：https://mathpretty.com/12451.html
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: