关键词：
【中文标题】Pytorch MNIST 自动编码器学习 10 位分类【英文标题】：Pytorch MNIST autoencoder to learn 10-digit classification 【发布时间】：2021-06-14 11:42:28 【问题描述】：我正在尝试为 MNIST 构建一个简单的自动编码器，其中中间层只有 10 个神经元。我希望它能够学会对这 10 位数字进行分类，并且我认为这最终会导致最低的错误（wrt 再现原始图像）。
我有以下代码，我已经玩过很多次了。如果我运行它最多 100 个 epoch，损失并不会真正低于 1.0，如果我评估它，它显然不起作用。我错过了什么？
培训：
import torch
import torchvision as tv
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from torchvision.utils import save_image
num_epochs = 100
batch_size = 64
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
trainset = tv.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=4)
class Autoencoder(nn.Module):
def __init__(self):
super(Autoencoder,self).__init__()
self.encoder = nn.Sequential(
# 28 x 28
nn.Conv2d(1, 4, kernel_size=5),
nn.Dropout2d(p=0.2),
# 4 x 24 x 24
nn.ReLU(True),
nn.Conv2d(4, 8, kernel_size=5),
nn.Dropout2d(p=0.2),
# 8 x 20 x 20 = 3200
nn.ReLU(True),
nn.Flatten(),
nn.Linear(3200, 10),
nn.ReLU(True),
# 10
nn.Softmax(),
# 10
)
self.decoder = nn.Sequential(
# 10
nn.Linear(10, 400),
nn.ReLU(True),
# 400
nn.Unflatten(1, (1, 20, 20)),
# 20 x 20
nn.Dropout2d(p=0.2),
nn.ConvTranspose2d(1, 10, kernel_size=5),
# 24 x 24
nn.ReLU(True),
nn.Dropout2d(p=0.2),
nn.ConvTranspose2d(10, 1, kernel_size=5),
# 28 x 28
nn.ReLU(True),
nn.Sigmoid(),
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
model = Autoencoder().cpu()
distance = nn.MSELoss()
#optimizer = torch.optim.Adam(model.parameters(), weight_decay=1e-5)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
for epoch in range(num_epochs):
for data in dataloader:
img, _ = data
img = Variable(img).cpu()
output = model(img)
loss = distance(output, img)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('epoch [/], loss: :.4f'.format(epoch+1, num_epochs, loss.item()))
训练损失已经表明事情不工作，但打印出混淆矩阵（在这种情况下不一定是单位矩阵，因为神经元可以任意排序，但应该是行列可重新排序的并近似身份，如果这可行的话）：
import numpy as np
confusion_matrix = np.zeros((10, 10))
batch_size = 20*1000
testset = tv.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True, num_workers=4)
for data in dataloader:
imgs, labels = data
imgs = Variable(imgs).cpu()
encs = model.encoder(imgs).detach().numpy()
for i in range(len(encs)):
predicted = np.argmax(encs[i])
actual = labels[i]
confusion_matrix[actual][predicted] += 1
print(confusion_matrix)
【问题讨论】：
【参考方案1】：自动编码器在技术上通常不用作分类器。他们学习如何将给定的图像编码为一个短向量，并从编码的向量中重建相同的图像。这是一种将图像压缩成短向量的方法：
由于您要训练具有分类功能的自动编码器，我们需要对模型进行一些更改。首先，会有两种不同的损失：
-
MSE 损失：当前自动编码器重建损失。这将迫使网络通过采用压缩表示来输出尽可能接近给定图像的图像。
分类损失：经典交叉熵应该可以解决问题。这种损失将采用压缩表示（C 维）和目标标签来计算负对数似然损失。这种损失将迫使编码器输出压缩表示，使其与目标类很好地对齐。
我对您的代码进行了几处更改，以使组合模型正常工作。首先我们来看代码：
import torch
import torchvision as tv
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from torchvision.utils import save_image
num_epochs = 10
batch_size = 64
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
trainset = tv.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = tv.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=4)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True, num_workers=4)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class Autoencoderv3(nn.Module):
def __init__(self):
super(Autoencoderv3,self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(1, 4, kernel_size=5),
nn.Dropout2d(p=0.1),
nn.ReLU(True),
nn.Conv2d(4, 8, kernel_size=5),
nn.Dropout2d(p=0.1),
nn.ReLU(True),
nn.Flatten(),
nn.Linear(3200, 10)
)
self.softmax = nn.Softmax(dim=1)
self.decoder = nn.Sequential(
nn.Linear(10, 400),
nn.ReLU(True),
nn.Unflatten(1, (1, 20, 20)),
nn.Dropout2d(p=0.1),
nn.ConvTranspose2d(1, 10, kernel_size=5),
nn.ReLU(True),
nn.Dropout2d(p=0.1),
nn.ConvTranspose2d(10, 1, kernel_size=5)
)
def forward(self, x):
out_en = self.encoder(x)
out = self.softmax(out_en)
out = self.decoder(out)
return out, out_en
model = Autoencoderv3().to(device)
distance = nn.MSELoss()
class_loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
mse_multp = 0.5
cls_multp = 0.5
model.train()
for epoch in range(num_epochs):
total_mseloss = 0.0
total_clsloss = 0.0
for ind, data in enumerate(dataloader):
img, labels = data[0].to(device), data[1].to(device)
output, output_en = model(img)
loss_mse = distance(output, img)
loss_cls = class_loss(output_en, labels)
loss = (mse_multp * loss_mse) + (cls_multp * loss_cls) # Combine two losses together
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Track this epoch's loss
total_mseloss += loss_mse.item()
total_clsloss += loss_cls.item()
# Check accuracy on test set after each epoch:
model.eval() # Turn off dropout in evaluation mode
acc = 0.0
total_samples = 0
for data in testloader:
# We only care about the 10 dimensional encoder output for classification
img, labels = data[0].to(device), data[1].to(device)
_, output_en = model(img)
# output_en contains 10 values for each input, apply softmax to calculate class probabilities
prob = nn.functional.softmax(output_en, dim = 1)
pred = torch.max(prob, dim=1)[1].detach().cpu().numpy() # Max prob assigned to class
acc += (pred == labels.cpu().numpy()).sum()
total_samples += labels.shape[0]
model.train() # Enables dropout back again
print('epoch [/], loss_mse: :.4f loss_cls: :.4f Acc on test: :.4f'.format(epoch+1, num_epochs, total_mseloss / len(dataloader), total_clsloss / len(dataloader), acc / total_samples))
此代码现在应该将模型训练为分类器和生成自动编码器。但总的来说，这种类型的方法对于模型训练可能有点棘手。在这种情况下，MNIST 数据很简单，可以将这两个互补的损失训练在一起。在更复杂的情况下，例如生成对抗网络 (GAN)，他们应用模型训练切换、冻结一个模型等来训练整个模型。这种自动编码器模型可以轻松地在 MNIST 上进行训练，而无需使用这些技巧：
epoch [1/10], loss_mse: 0.8928 loss_cls: 0.4627 Acc on test: 0.9463
epoch [2/10], loss_mse: 0.8287 loss_cls: 0.2105 Acc on test: 0.9639
epoch [3/10], loss_mse: 0.7803 loss_cls: 0.1574 Acc on test: 0.9737
epoch [4/10], loss_mse: 0.7513 loss_cls: 0.1290 Acc on test: 0.9764
epoch [5/10], loss_mse: 0.7298 loss_cls: 0.1117 Acc on test: 0.9762
epoch [6/10], loss_mse: 0.7110 loss_cls: 0.1017 Acc on test: 0.9801
epoch [7/10], loss_mse: 0.6962 loss_cls: 0.0920 Acc on test: 0.9794
epoch [8/10], loss_mse: 0.6824 loss_cls: 0.0859 Acc on test: 0.9806
epoch [9/10], loss_mse: 0.6733 loss_cls: 0.0797 Acc on test: 0.9814
epoch [10/10], loss_mse: 0.6671 loss_cls: 0.0764 Acc on test: 0.9813
如您所见，mse 损失和分类损失都在减少，而在测试集上的准确率正在提高。在代码中，MSE 损失和分类损失相加。这意味着从每个损失计算的各个梯度正在相互对抗以迫使网络进入它们的方向。我添加了损失乘数来控制每个损失的贡献。如果 MSE 具有更高的乘数，网络将从 MSE 损失中获得更多的梯度，这意味着它将更好地学习重建，如果 CLS 损失具有更高的乘数，网络将获得更好的分类精度。您可以使用这些乘数来查看最终结果如何变化，但 MNIST 是一个非常简单的数据集，因此可能很难看出差异。目前，它在重建输入方面做得还不错：
import numpy as np
import matplotlib.pyplot as plt
model.eval()
img, labels = list(dataloader)[0]
img = img.to(device)
output, output_en = model(img)
inp = img[0:10, 0, :, :].squeeze().detach().cpu()
out = output[0:10, 0, :, :].squeeze().detach().cpu()
# Just some trick to concatenate first ten images next to each other
inp = inp.permute(1,0,2).reshape(28, -1).numpy()
out = out.permute(1,0,2).reshape(28, -1).numpy()
combined = np.vstack([inp, out])
plt.imshow(combined)
plt.show()
我相信通过更多的训练和微调损失乘数，您可以获得更好的结果。
最后，解码器接收编码器输出的 softmax。这意味着解码器尝试从输入的 0 - 1 概率创建输出图像。因此，如果 softmax 概率向量在输入位置 0 处为 0.98，而在其他位置接近于 0，则解码器应输出看起来像 0.0 的图像。这里我给出网络输入来创建 0 到 9 个重建：
test_arr = np.zeros([10, 10], dtype = np.float32)
ind = np.arange(0, 10)
test_arr[ind, ind] = 1.0
model.eval()
img = torch.from_numpy(test_arr).to(device)
out = model.decoder(img)
out = out[0:10, 0, :, :].squeeze().detach().cpu()
out = out.permute(1,0,2).reshape(28, -1).numpy()
plt.imshow(out)
plt.show()
我还对代码进行了一些小改动，打印 epoch average loss 等，这并没有真正改变训练逻辑，所以你可以在代码中看到这些变化，如果有什么看起来很奇怪，请告诉我。
【讨论】：
我这样做只是为了好玩，我想看看我是否可以让编码器在自动编码器中间作为“副作用”进行准确的数字分类。在我看来，将编码维度设置为 10，这是最佳编码，或者至少是最佳编码之一.. 见我上面的回答：出于数学上关于 softmax 的原因，这行不通，尝试使用不同温度的 Gumbal-Softmax，它可能会正常工作。否则，在离散变分自编码器的空间中有很多工作。 它实际上可以工作，您可以将两个损失加在一起来训练网络：分类损失和重建损失。请参阅我编辑的答案。【参考方案2】：我能够将您的代码带到一个至少可以收敛的版本。总之，我认为它可能存在多个问题：归一化（为什么是这些值？），一些不必要的 relus，太高的学习率，MSE 损失而不是交叉熵，主要是我不认为 softmax 在瓶颈由于梯度消失的原因，图层以这种方式工作，请参见此处
https://www.quora.com/Does-anyone-ever-use-a-softmax-layer-mid-neural-network-rather-than-at-the-end
也许有人可以使用 Gumbel softmax 解决这个问题：https://arxiv.org/abs/1611.01144
此外，已经有论文实现了这一点，但作为变分自动编码器而不是普通自动编码器，请参见此处：https://arxiv.org/abs/1609.02200。
现在你可以使用这个修改，它至少会收敛，然后逐步修改，看看是什么破坏了它。
至于分类，标准方法是使用经过训练的编码器从图像中生成特征，然后在此基础上使用普通分类器（SVG 左右）。
batch_size = 16
transform = transforms.Compose([
transforms.ToTensor(),
])
trainset = MNIST(root='./data/', train=True, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=8)
class Autoencoder(nn.Module):
def __init__(self):
super(Autoencoder,self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(1, 2, kernel_size=5),
nn.ReLU(),
nn.Conv2d(2, 4, kernel_size=5),
)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(4, 10, kernel_size=5),
nn.ReLU(),
nn.ConvTranspose2d(10, 1, kernel_size=5),
nn.Sigmoid(),
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
model = Autoencoder().cpu()
distance = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001,weight_decay=1e-5)
num_epochs = 20
outputs = []
for epoch in tqdm(range(num_epochs)):
for data in dataloader:
img, _ = data
img = Variable(img).cpu()
output = model(img)
loss = distance(output, img)
optimizer.zero_grad()
loss.backward()
optimizer.step()
outputs.append(output)
print('epoch [/], loss: :.4f'.format(epoch+1, num_epochs, loss.item()))
import matplotlib.pyplot as plt
% plotting epoch outputs
for k in range(0, 20):
plt.figure(figsize=(9, 2))
imgs = outputs[k].detach().numpy()
for i, item in enumerate(imgs):
plt.imshow(item[0])
plt.title(str(i))
plt.show()
【讨论】：
关于归一化值的说明，这些实际上是训练数据的均值和标准：discuss.pytorch.org/t/normalization-in-the-mnist-example/457 不知道你为什么需要“让它编译”，我从我的 ipython 笔记本上复制/粘贴了这个。 抱歉，已编辑：我的意思当然是“收敛” 为了进一步提高与 sigmoid 输出的收敛性，可以通过使用交叉熵损失来改进微调 mnist 的深度自动编码器模型
】微调mnist的深度自动编码器模型【英文标题】：Finetuningdeepautoencodermodelformnist【发布时间】：2019-10-0112:39:03【问题描述】：我已经为mnist数据集开发了一个3层深度自动编码器模型，因为我只是在这个玩具数据集上练习，因为我... 查看详情
PyTorch 时尚-MNIST (ETL)
】PyTorch时尚-MNIST(ETL)【英文标题】：PyTorchFashion-MNIST(ETL)【发布时间】：2019-08-0107:02:51【问题描述】：我是深度学习和PyTorch的新手，所以如果有些问题看起来很愚蠢或者我的提问格式不正确，请多多包涵。作为深度学习PyTorch系列... 查看详情
pytorch实现mlp并在mnist数据集上验证(代码片段)
...找一份源码以参考，重点在于照着源码手敲一遍，以熟悉pytorch的基本操作。实验要求熟悉pytorch的基本操作：用pytorch实现MLP，并在MNIST数据集上进行训练环境配置实验环境如下：Win10python3.8Anaconda3Cuda10.2+cudnnv7GPU:NVIDIAGeForceMX250配置... 查看详情
pytorch学习-训练cifar10分类器(代码片段)
output_10_1.pngTRAININGACLASSIFIER参考PytorchTutorial:DeepLearningwithPyTorch:A60MinuteBlitz在学会了以下后：定义神经网络计算损失函数更新权重WhataboutdataGenerally,whenyouhavetodealwithimage,text,audioorvideodata,youcanusestandardpythonpackagesthatloaddataintoanumpyarray.The... 查看详情
pytorch学习(代码片段)
Pytorch1_手写字识别数据集的载入数据集展示网络搭建模型训练训练损失函数图模型预测下面将构造一个三层全连接层的神经网络来对手写数字进行识别。数据集的载入importtorchfromtorchimportnnfromtorch.nnimportfunctionalasFfromtorchimportoptimim... 查看详情
如何使用 pytorch 构建多维自动编码器
】如何使用pytorch构建多维自动编码器【英文标题】：howtobuildamultidimensionalautoencoderwithpytorch【发布时间】：2019-10-1815:17:19【问题描述】：我遵循了序列自动编码器的这个很好的答案，LSTMautoencoderalwaysreturnstheaverageoftheinputsequence.但... 查看详情
如何使用 PyTorch 构建 LSTM 自动编码器？
】如何使用PyTorch构建LSTM自动编码器？【英文标题】：HowcanIbuildanLSTMAutoEncoderwithPyTorch?【发布时间】：2020-05-0819:44:09【问题描述】：我的数据是DataFrame：dOpendHighdLowdClosedVolumeday_of_week_0day_of_week_1...month_6month_7month_8month_9month_10month_11m 查看详情
pytorch学习-7：rnn循环神经网络(分类)(代码片段)
pytorch学习-7：RNN循环神经网络（分类）1.加载MNIST手写数据1.1数据预处理2.RNN模型建立3.训练4.预测参考循环神经网络让神经网络有了记忆,对于序列话的数据,循环神经网络能达到更好的效果.1.加载MNIST手写数据importtorchfr... 查看详情
跟着b站学习pytorch-p13mnist手写数字图片分类问题(代码片段)
...概述上一节学习了逻辑回归，在这一节里,我们将使用PyTorch来解决分类任务.关于测试数据集MNIST:MNIST包含0~9的手写数字,共有60000个训练集和10000个测试集.数据的格式为单通道28*28的灰度图.数据集很重要。我就是这里翻车了ÿ... 查看详情
pytorch实战|第p1周：实现mnist手写数字识别(代码片段)
🍨本文为🔗365天深度学习训练营中的学习记录博客🍦参考文章：365天深度学习训练营-第P1周：实现mnist手写数字识别（训练营内部成员可读）🍖原作者：K同学啊|接辅导、项目定制🏡我的... 查看详情
pytorch实战|第p1周：实现mnist手写数字识别(代码片段)
🍨本文为🔗365天深度学习训练营中的学习记录博客🍦参考文章：365天深度学习训练营-第P1周：实现mnist手写数字识别（训练营内部成员可读）🍖原作者：K同学啊|接辅导、项目定制🏡我的... 查看详情
小白学习pytorch教程十一基于mnist数据集训练第一个生成性对抗网络(代码片段)
@Author：RunsenGAN是使用两个神经网络模型训练的生成模型。一种模型称为生成网络模型，它学习生成新的似是而非的样本。另一个模型被称为判别网络，它学习区分生成的例子和真实的例子。生成性对抗网络2014... 查看详情
小白学习pytorch教程十一基于mnist数据集训练第一个生成性对抗网络(代码片段)
@Author：RunsenGAN是使用两个神经网络模型训练的生成模型。一种模型称为生成网络模型，它学习生成新的似是而非的样本。另一个模型被称为判别网络，它学习区分生成的例子和真实的例子。生成性对抗网络2014... 查看详情
小白学习pytorch教程十七pytorch中数据集torchvision和torchtext(代码片段)
@Author：Runsen对于PyTorch加载和处理不同类型数据，官方提供了torchvision和torchtext。之前使用torchDataLoader类直接加载图像并将其转换为张量。现在结合torchvision和torchtext介绍torch中的内置数据集Torchvision中的数据集MNISTMNIST... 查看详情
365计划-1pytorch实现mnist手写数字识别(代码片段)
🍨本文为🔗365天深度学习训练营中的学习记录博客🍦参考文章地址：365天深度学习训练营-第P1周：mnist手写数字识别🍖作者：K同学啊###本项目来自K同学在线指导###importtorch.nnasnnimportmatplotlib.pyplotasplti... 查看详情
pytorch中mnist的transforms图像处理
什么是mnistMNIST数据集是一个公开的数据集，相当于深度学习的helloworld，用来检验一个模型/库/框架是否有效的一个评价指标。MNIST数据集是由0〜9手写数字图片和数字标签所组成的，由60000个训练样本和10000个测试样本... 查看详情
pytorch学习-7：rnn循环神经网络(分类)(代码片段)
pytorch学习-7：RNN循环神经网络（分类）1.加载MNIST手写数据1.1数据预处理2.RNN模型建立3.训练4.预测参考循环神经网络让神经网络有了记忆,对于序列话的数据,循环神经网络能达到更好的效果.1.加载MNIST手写数据importtorchfr... 查看详情
利用knnsvmcnn逻辑回归mlprnn等方法实现mnist数据集分类（pytorch实现）(代码片段)
电脑配置：python3.6**Pytorch1.2.0**torchvision0.4.0想学习机器学习和深度学习的同学，首先找个比较经典的案例和经典的方法自己动手试一试，分析这些方法的思想和每一行代码是一个快速入门的小技巧，今天我们... 查看详情