堆叠自编码器
对于很多数据来说，仅使用两层神经网络的自编码器结构还不足以获取一种好的数据表示，为了获取更好的数据表示，我们可以使用更深层的神经网络。深层神经网络作为自编码器提取的数据表示一般会更加抽象，能够更好地捕捉到数据的语义信息。在实践中经常使用逐层堆叠的方式来训练一个深层的自编码器，称为堆叠自编码器（SAE）。堆叠自编码器一般可以采用逐层训练来学习网络参数。
降噪自编码器
我们使用自编码器的目的是得到有效的数据表示，而有效的数据表示除了具有最小重构误差或稀疏性等性质之外，还可以要求其具备其他性质，比如对数据部分损坏的鲁棒性。高维数据（如图像）一般具有一定的冗余信息，比如我们可以根据一张部分损坏的图像联想到完整的内容。因此我们希望自编码器也能够从部分损坏的数据中得到有效的数据表示，并能够恢复出完整的原始信息。
降噪自编码器就是一种通过引入噪声来增加编码鲁棒性的自编码器。对于一个向量\(x\)，我们首先根据一个比例\(\mu\)（一般小于0.5）随机将\(x\)的一些维度的值设置为0，得到一个被损坏的向量\(\tilde x\)，然后将被损坏的向量\(\tilde x\)输入给自编码器得到编码\(z\)，并重构出无损的原始输入\(x\)。
堆叠降噪自编码器
堆叠降噪自编码器（SDAE）与降噪自编码器（DAE）的关系就像堆叠自编码器（SAE）与自编码器（AE）之间的关系。SDAE的输入是加入噪声的原始数据\(x\)，将DAE原先的单隐藏层堆叠多次便是SDAE。
代码实现
本文利用pytorch实现了SDAE，数据集是MNIST数据，我们通过对原始图片加入一定比例的椒盐噪声，然后训练能够重构出无损图片的SDAE。下图是无损图和加入噪声的图。
 |
 |
文件结构
- config.py：保存模型超参数
import argparse
class HyperParam:
def __init__(self):
self.parse = argparse.ArgumentParser()
self.parse.add_argument("--epoch", type=int, default=40)
self.parse.add_argument("--batch_size", type=int, default=64)
self.parse.add_argument("--image_size", type=int, default=28 * 28)
self.parse.add_argument("--lr", type=float, default=0.0002)
- sdae.py：堆叠降噪自编码器模型实现
import os
import torch
from config import HyperParam
import torch.nn as nn
import torch.optim as optim
import torchvision
import torch.utils.data as Data
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
hyparam = HyperParam()
opt = hyparam.parse.parse_args()
datapath = "C:/Users/DZL102/Desktop/VAE/data"
train_dataset = torchvision.datasets.MNIST(root=datapath,
train=True,
transform=transforms.ToTensor())
train_loader = Data.DataLoader(dataset=train_dataset,
batch_size=opt.batch_size,
shuffle=True)
test_dataset = torchvision.datasets.MNIST(root=datapath,
transform=transforms.ToTensor())
test_loader = Data.DataLoader(dataset=test_dataset,
batch_size=opt.batch_size,
shuffle=True)
def make_noise(X, noise_prop):
X_clone = X.clone()
# X：batchsize, channel, height, width
batchsize, channel, height, width = X.shape
num = int(height * width * noise_prop)
for b in range(batchsize):
for c in range(channel):
for i in range(num):
h = np.random.randint(0, height)
w = np.random.randint(0, width)
if np.random.randint(0, 2) == 0:
X_clone[b, c, h, w] = 0 # 黑点
else:
X_clone[b, c, h, w] = 0.98 # 白点
return X_clone
def draw(X):
h, w = 2, 2
fig, axs = plt.subplots(nrows=h, ncols=w)
for i in range(h):
for j in range(w):
axs[i, j].imshow(X[(i + 1) * (j + 1) - 1, 0, :] * 255, cmap="gray")
axs[i, j].set_xticks([])
axs[i, j].set_yticks([])
plt.show()
class SDAE(nn.Module):
def __init__(self, in_size):
super().__init__()
self.encoder = nn.Sequential(
nn.Linear(in_size, 400),
nn.ReLU(),
nn.Linear(400, 100),
nn.ReLU())
self.decoder = nn.Sequential(
nn.Linear(100, 400),
nn.ReLU(),
nn.Linear(400, in_size))
self.sdae = nn.Sequential(self.encoder, self.decoder)
def forward(self, X):
return self.sdae(X)
model = SDAE(opt.image_size)
loss = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=opt.lr)
def train(epochs):
print("training..........")
for epoch in range(epochs):
for i, (X, _) in enumerate(train_loader):
y = X.view(-1, opt.image_size)
X = make_noise(X, 0.1)
X = X.view(-1, opt.image_size)
output = model(X)
train_loss = loss(output, y)
optimizer.zero_grad()
train_loss.backward()
optimizer.step()
test_loss = 0
with torch.no_grad():
for i, (X, _) in enumerate(test_loader):
X = X.view(-1, opt.image_size)
output = model(X)
test_loss += loss(output, X).item()
print("epoch [{}/{}], test_loss: {:.4f}".format(epoch + 1,
epochs, test_loss))
train(opt.epoch)
# 持久化模型
torch.save(model, 'model/model.pth')