漫谈autoencoder：降噪自编码器/稀疏自编码器/栈式自编码器（含tensorflow实现）

时间 2020-07-20 标签漫谈 autoencoder 降噪编码器稀疏 tensorflow 实现

0. 前言

在非监督学习中，最典型的一类神经网络莫过于autoencoder(自编码器)，它的目的是基于输入的unlabeled数据 $X=\{x^{(1)}, x^{(2)}, x^{(3)}, ...\}$ ，经过训练获得数据的一个降维特征表达 $H=\{h^{(1)}, h^{(2)}, h^{(3)}, ...\}$ 。以图像识别为例，隐层 $H$ 会提取出图像的边角，将这种更为抽象的特征做为后续的多层感知网络的输入，能够更好地表达输入图像，在图像分类等任务上得到更好的性能。
从最原始的自编码器衍生出不少不一样的种类：
- 降噪自编码器，接受加噪的输入来进行训练
- 稀疏自编码器，对隐层的激活输出进行正则，同一时间只有部分隐层神经元是活跃的
- 栈式自编码器，级联多个自编码器，逐层提取抽象特征php

1. 自编码器

1.1 定义

自编码器分为两个部分，编码器encoder和解码器decoder。一个单隐层的AE的网络结构以下图所示：
html

从上图能够看到，自编码器输出层的节点数与输入层相等，训练这个网络以指望获得近似恒等函数，如下分别对encoder/decoder以及损失函数进行表示：
编码器：
git

h = σ (W x + b)

$h=\sigma{(Wx+b)}$
解码器：

\hat{x} = σ (W^{^{'}} h + b^{^{'}})

$\hat{x}=\sigma{(W^{'}h+b^{'})}$
损失函数：

{W, b, W^{^{'}}, b^{^{'}}} = a r g m i n L o s s (x, x^{^{'}}) = | | x - x^{^{'}} | |^{2}

$\{W, b, W^{'}, b^{'}\}=argmin \; Loss(x, x^{'})=||x-x^{'}||^2$

1.2 tensorflow实现

咱们利用tensorflow实现一个自编码器，在MNIST数据库上进行测试，而且可视化输入图片和恢复后(reconstruction)图片的对比。选用激活函数为relu，设置隐层节点数为500，具体设置以下：github

training_epochs = 20
batch_size = 128
display_step = 1

corruption_level = 0
sparse_reg = 0

#
n_inputs = 784
n_hidden = 500
n_outputs = 10
ae = Autoencoder(n_layers=[n_inputs, n_hidden],
                          transfer_function = tf.nn.relu,
                          optimizer = tf.train.AdamOptimizer(learning_rate = 0.001),
                          ae_para = [corruption_level, sparse_reg])

下图是在测试集上对比输入和恢复的图片：
web

能够从上图看到，在测试数据经过自编码器完成恢复的效果很好，图像也很清晰，能够认为是几乎完美的重构。为了和下一节的降噪自编码器进行比较，咱们尝试在测试数据中加入一些高斯白噪声，以此来评估一下自编码器的抗噪性能。数据库

batch_xs, _ = mnist.test.next_batch(n)
batch_xs += np.random.normal(loc=0, scale=0.3, size=batch_xs.shape)

一样的在测试集上对比输入和恢复的图片以下图，能够看到自编码器有微弱的抗噪能力，可是不明显。
markdown

2. 降噪自编码器

2.1 定义

和自编码器不一样的是，降噪自编码的训练过程当中，输入的数据有一部分是“损坏”的，DAE(Denoising Autoencoder)的核心思想是，一个可以从中恢复出原始信号的神经网络表达未必是最好的，可以对“损坏”的原始数据编码、解码，而后还能恢复真正的原始数据，这样的特征才是好的。在论文“Stacked Denoising Autoencoders: Learning Useful Representations in a Deep Network with a Local Denoising Criterion”中，阐述了DAE的原理，以下图所示：
网络

对于输入的数据 ${x}$ 按照 $q_D$ 分布加入进行加噪“损坏”，从图式能够看出，这个加噪过程是按照必定的几率将输入层的某些节点清0，而后将 $\hat{x}$ 做为自编码器的输入进行训练。除了对输入层数据的处理不一样，其他部分DAE与AE彻底相似。dom

2.2 tensorflow实现

在用tensorflow实现的过程当中，咱们用dropout来完成这个加噪“损坏”过程。Dropout是指在模型训练时随机让网络某些隐含层节点的权重不工做，相似的，咱们将dropout做用在输入层而不是隐层，就能够完成对输入层数据按照必定几率清0的操做。代码实现以下：svg

self.x = tf.placeholder(tf.float32, [None, self.n_layers[0]])
self.keep_prob = tf.placeholder(tf.float32)

h = tf.nn.dropout(self.x, self.keep_prob)

在MNIST的训练集上对降噪自编码器进行训练，一样对加入高斯白噪声的测试数据进行编码解码恢复，对比输入和恢复的图片以下图所示，能够看到降噪自编码器相比自编码器有更好的抗噪能力，恢复的图片更清晰。

2.3 可视化特征提取

将编码器的输入层与隐层之间的权重矩阵 $W$ 进行可视化，降噪自编码器的特征图显示为：

做为对比，原始的自编码器的特征图显示为：

从以上两幅特征图对比能够看出，降噪自编码器确实在训练后学习到了有效的特征提取，例如手写体数字的”转角”，这类特征更有表明性。

3. 稀疏自编码器

3.1 定义

通常来讲，自编码器的隐层节点数小于输入层的节点数，即在训练过程当中，自编码器倾向于去学习数据内部的规律，例如相关性，那么自编码器学习的结果极可能相似于PCA，获得的是输入数据的一个降维表示。
那若是咱们设定隐层节点数大于输入层节点数，同时又想获得输入数据内一些有趣的结构和规律。咱们给自编器加上一个稀疏性的限制，即在同一时间，只有某些隐层节点是“活跃”的，这样整个自编码器就变成稀疏的。
假设隐层激活函数采用的是sigmoid，那么隐层输出为1表明这个节点很”活跃”，隐层输出为0表明这个节点”不活跃”。基于此，咱们引入KL离散度来衡量某个隐层节点的平均激活输出和咱们设定的稀疏度 $\rho$ 之间的类似性：

K L (ρ | | {\hat{ρ}}_{j}) = ρ l o g \frac{ρ}{{\hat{ρ}}_{j}} + (1 - ρ) l o g \frac{1 - ρ}{1 - {\hat{ρ}}_{j}}

$KL(\rho || \hat{\rho}_j)=\rho log{\frac{\rho}{\hat{\rho}_j} }+(1-\rho)log{\frac{1-\rho}{1-\hat{\rho}_j}}$
其中

{\hat{ρ}}_{j} = \frac{1}{m} \sum_{i = 1}^{m} [a_{j}^{(2)} x^{(i)}]

$\hat{\rho}_j=\frac{1}{m}\sum\limits_{i = 1}^{m}[a^{(2)}_j{x^{(i)}}]$ ，

m

$m$ 为训练样本的个数，

a_{j}^{(2)} x^{(i)}

$a^{(2)}_j{x^{(i)}}$ 为隐层第

j

$j$ 个节点对

i

$i$ 个样本的响应输出。通常来讲咱们设定稀疏系数

ρ = 0.05 或 0.1

$\rho=0.05或0.1$ 。KL离散度越大表明

ρ

$\rho$ 和

{\hat{ρ}}_{j}

$\hat{\rho}_j$ 之间相差越大，KL离散度等于0表明二者彻底相等

ρ = {\hat{ρ}}_{j}

$\rho=\hat{\rho}_j$ 。
所以，咱们能够将KL离散度做为正则项加入到损失函数中，以此对整个自编码器网络的稀疏行进行约束：

J_{s p a r s e} (W, b) = J (W, b) + β \sum_{j = 1}^{s_{2}} K L (ρ | | {\hat{ρ}}_{j})

$J_{sparse}(W,b)=J(W,b)+\beta \sum\limits_{j=1}^{s_2}KL(\rho || \hat{\rho}_j)$

3.2 tensorflow实现

在loss函数中加入正则项：

self.sparsity_level = 0.1

if self.sparse_reg == 0:
    self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
else:
    self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))+\
                self.sparse_reg * self.kl_divergence(self.sparsity_level, self.hidden_encode[-1])

def kl_divergence(self, p, p_hat):
    return tf.reduce_mean(p * tf.log(tf.clip_by_value(p, 1e-8, tf.reduce_max(p)))
                          - p * tf.log(tf.clip_by_value(p_hat, 1e-8, tf.reduce_max(p_hat)))
                          + (1 - p) * tf.log(tf.clip_by_value(1-p, 1e-8, tf.reduce_max(1-p)))
                          - (1 - p) * tf.log(tf.clip_by_value(1-p_hat, 1e-8, tf.reduce_max(1-p_hat))))

下图的运行结果是稀疏自编器经过训练学习到的特征显示：

从上图确实看不大出，稀疏自编码器提取的特征有什么有意思的部分，可是对于加噪输入图像的去噪仍是颇有效果，见下图所示测试集上对比输入和恢复的图片：

4. 栈式自编码器

顾名思义，栈式自编码器就是多个自编码器级联，以完成逐层特征提取的任务，最终获得的特征更有表明性，而且维度很小。
栈式自编码器的训练过程是，n个AE按顺序训练，第1个AE训练完成后，将其编码器的输出做为第2个AE的输入，以此类推。最后获得的特征做为分类器的输入，完成最终的分类训练。以下四幅图所示：

在逐层训练结束后，还须要一个微调过程(Fine tuning)。大意以下：逐层训练后，每层AE的权重和softmax分类层的权重已经有一个pretrain的值，此时，咱们再将整个网络链接起来，用数据进行一次训练，让每层的权重参数同时获得改善。
第一层降噪自编码器经过训练学习到的特征显示以下图：

第二层降噪自编码器经过训练学习到的特征显示以下图：

为了比较分类性能，咱们对比降噪自编码器和栈式自编码器，在MNIST测试集上进行分类测试，分类的准确度对好比下。能够看到栈式自编码器的分类准确度要好于单个的降噪自编码器。

降噪自编码器
Accuracy on the test set:
0.9634

栈式降噪自编码器
Accuracy on the test set:
*************************Softmax*****************************
Test accuracy before fine-tune
0.7213
*************************Fine tune*****************************
0.9681

5. 项目地址

https://github.com/wblgers/tensorflow_stacked_denoising_autoencoder

代码能够直接运行，注释还待完善，喜欢的话能够点个star.

6. 参考资料

(1) https://en.wikipedia.org/wiki/Autoencoder
(2) http://deeplearning.stanford.edu/wiki/index.php/Stacked_Autoencoders
(3) http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/
(4) http://www.javashuo.com/article/p-wboawidw-md.html