如何解决Pytorch MNIST 自动编码器学习 10 位分类
我正在尝试为 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,# 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),# 400
nn.Unflatten(1,(1,20,20)),# 20 x 20
nn.Dropout2d(p=0.2),nn.ConvTranspose2d(1,10,# 24 x 24
nn.ReLU(True),nn.ConvTranspose2d(10,1,# 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()))
训练损失已经表明这件事不起作用，但打印出混淆矩阵（在这种情况下不一定是单位矩阵，因为神经元可以任意排序，但应该是 row-col-reordarable并近似身份，如果这行得通）：
import numpy as np
confusion_matrix = np.zeros((10,10))
batch_size = 20*1000
testset = tv.datasets.MNIST(root='./data',train=False,transform=transform)
dataloader = torch.utils.data.DataLoader(testset,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)
解决方法
我能够将您的代码带到至少会收敛的版本。总而言之，我认为它可能存在多个问题：归一化（为什么是这些值？）、一些不必要的依赖、过高的学习率、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,)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(4,10,nn.ConvTranspose2d(10,1,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()
自编码器在技术上一般不用作分类器。他们学习如何将给定的图像编码为一个短向量，并从编码的向量中重建相同的图像。这是一种将图像压缩成短向量的方法：
由于您想训练具有分类功能的自动编码器，我们需要对模型进行一些更改。首先，会有两种不同的损失：
- 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',transform=transform)
testset = tv.datasets.MNIST(root='./data',train=False,transform=transform)
dataloader = torch.utils.data.DataLoader(trainset,num_workers=4)
testloader = torch.utils.data.DataLoader(testset,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,nn.Dropout2d(p=0.1),nn.ReLU(True),nn.Conv2d(4,8,nn.Flatten(),nn.Linear(3200,10)
)
self.softmax = nn.Softmax(dim=1)
self.decoder = nn.Sequential(
nn.Linear(10,400),nn.Unflatten(1,(1,20,20)),nn.ConvTranspose2d(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,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,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,:,:].squeeze().detach().cpu()
out = output[0:10,:].squeeze().detach().cpu()
# Just some trick to concatenate first ten images next to each other
inp = inp.permute(1,2).reshape(28,-1).numpy()
out = out.permute(1,-1).numpy()
combined = np.vstack([inp,out])
plt.imshow(combined)
plt.show()
我相信通过更多的训练和微调损失乘数，你可以获得更好的结果。
最后，解码器接收编码器输出的 softmax。这意味着解码器尝试从输入的 0 - 1 概率创建输出图像。因此，如果输入位置 0 处的 softmax 概率向量为 0.98，而在其他位置接近于零，则解码器应输出看起来像 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,:].squeeze().detach().cpu()
out = out.permute(1,-1).numpy()
plt.imshow(out)
plt.show()
我还在代码中做了一些小改动，打印了 epoch 平均损失等。这并没有真正改变训练逻辑，所以你可以在代码中看到这些变化，如果有什么看起来很奇怪，请告诉我。
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。