自编码器
自编码器的结构
- 为避免自编码器学出:原始数据*1=重建数据,这种无用的结构,要点是中间层要比输入层低维,强制其在编码时产生信息损失。
- 还有一种做法是:去噪自编码器,也就是对输入数据加入人为随机噪声,然后让解码器重建出没有噪声的图像,那这样就可以避免自编码学出乘1这种结构,因为乘1不能恢复没有噪声的图像。
自编码器的原理理解
- 自编码器输入是高维数据,中间隐藏层是低维特征,输出是和原始输入数据相同维度的重建数据。
- 输入的数据看起来是随机的,但其实存在着某种结构。某种规律
- 自编码器本质是在做投影,将高维数据投影成低维特征。编码器部分的网络存储了高维数据到低维特征的投影函数(这个函数可能不是常规的可解析的)。解码器部分的网络存储了低维特征到高维数据的反投影函数。
举个例子:
- 对于一系列3维的输入数据,其在空间中的分布如下图表示。
- 当然,对于呈现这样分布的每个点我们可以用3维点(x,y,z)来表示,但是我们可以明显地发现这些数据分布其实是被限制在1维螺旋中的,也就是说,只要我们记住这个螺旋函数f,那么每个点我们用1维特征(θ)就能表示。也即,θ=f(x,y,z)。
- 这里,3维的(x,y,z)就是输入自编码器的高维数据,1维θ就是自编码器学习得到(可以说是投影产生)的低维特征,投影函数f就是自编码器的编码器本身,通过网络结构和参数表示。
- 解码器则将低维特征反投影回高维数据,本质上在学这么一个函数(x,y,z)=g(θ)。
- f 和 g 就是数学中的函数和反函数
- 这里的例子中,点(3,0,0.5)就可以用2Π来表示,(x,y,z)与θ的关系则存储与自编码器网络中,
- 这里(x,y,z)与θ的关系有着显式的解析函数,但实际应用中,高维数据和低维特征的关系可能及其复杂,其函数关系无法用解析式表达,此时就可以通过神经网络来表达,神经网络的高参数量和非线性使其具备很强的拟合能力,只有参数量够,理论上神经网络可以拟合任意的函数。
- 解码器: 从低维到高维
自编码器的作用
- 训练好的自编码器,其编码器部分将是一个高效的特征提取器,提取到的特征可以用于很多任务,如分类,压缩。
- 训练好的一组自编码器(包含编码器和解码器),可以用来做异常数据检测,如果数据异常,也就是其分布不是我们之前学习的那种规律,那么重建误差将会很大。反之我们可以根据重建误差很大来推断输入数据是异常的。
自编码器的代码实现
数据集是Minist
import os
import torch
from torch import nn, optim
from torch.autograd import Variable
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
from torchvision.utils import save_image
# 加载数据集
def get_data():
data_tf = transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])
train_data = datasets.MNIST(root='./data', train=True, transform=data_tf, download=True)
train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size, drop_last=True)
return train_loader
class VAE(nn.Module):
def __init__(self):
super(VAE, self).__init__()
self.fc1 = nn.Linear(784, 400)
self.fc21 = nn.Linear(400, 20) # 均值
self.fc22 = nn.Linear(400, 20) # 方差
self.fc3 = nn.Linear(20, 400)
self.fc4 = nn.Linear(400, 784)
def encoder(self, x):
h1 = F.relu(self.fc1(x))
mu = self.fc21(h1)
logvar = self.fc22(h1)
return mu, logvar
def decoder(self, z):
h3 = F.relu(self.fc3(z))
x = F.tanh(self.fc4(h3))
return x
# 重新参数化
def reparametrize(self, mu, logvar):
std = logvar.mul(0.5).exp_() # 计算标准差
if torch.cuda.is_available():
eps = torch.cuda.FloatTensor(std.size()).normal_() # 从标准的正态分布中随机采样一个eps
else:
eps = torch.FloatTensor(std.size()).normal_()
eps = Variable(eps)
return eps.mul(std).add_(mu)
def forward(self, x):
mu, logvar = self.encoder(x)
z = self.reparametrize(mu, logvar)
return self.decoder(z), mu, logvar
def loss_function(recon_x, x, mu, logvar):
MSE = reconstruction_function(recon_x, x)
# loss = 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)
KLD_element = mu.pow(2).add_(logvar.exp()).mul_(-1).add_(1).add_(logvar)
KLD = torch.sum(KLD_element).mul_(-0.5)
# KL divergence
return MSE + KLD
def to_img(x):
x = (x + 1.) * 0.5
x = x.clamp(0, 1)
x = x.view(x.size(0), 1, 28, 28)
return x
if __name__ == '__main__':
# 超参数设置
batch_size = 128
lr = 1e-3
epoches = 100
model = VAE()
if torch.cuda.is_available():
model.cuda()
train_data = get_data()
reconstruction_function = nn.MSELoss(reduction='sum')
optimizer = optim.Adam(model.parameters(), lr=lr)
for epoch in range(epoches):
for img, _ in train_data:
img = img.view(img.size(0), -1)
img = Variable(img)
if torch.cuda.is_available():
img = img.cuda()
# forward
output, mu, logvar = model(img)
loss = loss_function(output, img, mu, logvar)/img.size(0)
# backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
print("epoch=", epoch, loss.data.float())
if (epoch+1) % 10 == 0:
print("epoch = {}, loss is {}".format(epoch+1, loss.data))
pic = to_img(output.cpu().data)
if not os.path.exists('./vae_img1'):
os.mkdir('./vae_img1')
save_image(pic, './vae_img1/image_{}.png'.format(epoch + 1))
torch.save(model, './vae.pth')
总结
- 自编码器本质就是将高维数据投影成低维特征,编码器网络拟合着投影函数,解码器网络拟合着反投影函数。
- 神经网络本质就是一个拟合函数。