个人学习记录

自编码器的概念

自编码器(Auto-Encoder)，是一种利用反向传播算法使得输出值等于输入值的神经网络，它先将输入压缩成潜在空间表征，然后通过这种表征来重构输出。自编码器由两部分组成：

编码器：这部分能将输入压缩成潜在空间表征，可以用编码函数h=f(x)表示。

解码器：这部分能重构来自潜在空间表征的输入，可以用解码函数r=g(h)表示。

整个自编码器可以用函数g(f(x)) = r来描述，其中输出r与原始输入x相近。该网络的目的是重构其输入，使其隐藏层学习到该输入的良好表征。如果输入完全等于输出，即g(f(x))=x，该网络毫无意义。所以需要向自编码器强加一些约束，使它只能近似地复制。这些约束强制模型考虑输入数据的哪些部分需要被优先复制，因此它往往能学习到数据的有用特性。一般情况下有两种约束：

1.令隐层的维度小于输入的维度，称为不完备的(under complete)。编码器将数据降维、解码器再还原数据。类似于PCA。如果隐藏节点比可视节点（输入、输出）少的话，由于被迫的降维，自编码器会自动习得训练样本的特征（变化最大，信息量最多的维度）。

2.令隐层的维度大于输入数据的维度，称为过完备(over complete)。如果隐藏节点数目过多，自编码器可能会习得一种“恒等函数，即直接把输入复制过去作为输出。因此需要添加其它的约束，比如正则化、稀疏性等。

自编码器的分类

根据对隐层特征侧重点的不同，出现了各种不同的自编码器的变种，如下图:[https://www.zhihu.com/question/41490383/answer/103006793]

堆栈自动编码器：自编码器的编码器和解码器可以采用深层的架构，这就是堆栈自动编码器或者深度自动编码器，本质上就是增加中间特征层数。以前栈式自编码器的训练过程是，n个AE按顺序训练，第1个AE训练完成后，将其编码器的输出作为第2个AE的输入，以此类推。最后再对整个网络进行Fine turning。但是现在的深度学习技术已经可以直接进行多层训练而无需逐层训练。

卷积自编码器：在编码器和解码器中使用卷积层抽取和还原特征。

正则自编码器：使用的损失函数可以鼓励模型学习其他特性（除了将输入复制到输出），而不必限制使用浅层的编码器和解码器以及小的编码维数来限制模型的容量。即使模型容量大到足以学习一个无意义的恒等函数，非线性且过完备的正则自编码器仍然能够从数据中学到一些关于数据分布的有用信息。常用的正则化有L1正则化和L2正则化。L2正则化的损失函数如下图：

上式中的lambda为权重衰减系数。

去噪自编码器（Denoising Auto-Encoder, DAE）：接收带噪声的数据，并将未带噪声的数据作为训练目标，得到一个用于去噪的自编码器。我们可以不对对损失函数添加惩罚，而是通过改变损失函数的重构误差项，得到一个可以学习一些有用的东西的自编码器。这可以通过给输入象征添加一些噪声并使自编码器学会删除它来实现。通过这种方式，编码器将提取最重要的特征并学习数据更具鲁棒性的表示。我们可以不对对损失函数添加惩罚，而是通过改变损失函数的重构误差项，得到一个可以学习一些有用的东西的自编码器。这可以通过给输入象征添加一些噪声并使自编码器学会删除它来实现。通过这种方式，编码器将提取最重要的特征并学习数据更具鲁棒性的表示。

稀疏自编码器(Sparse Auto-Encoder,SAE)：正则自编码器要求的是隐层的权重不能太大，而SAE的是要求隐层的神经元添加稀疏性限制。所谓稀疏性，就是对一对输入图像，隐藏节点中被激活的节点数（输出接近1）远远小于被抑制的节点数目（输出接近0）。那么使得神经元大部分的时间都是被抑制的限制则被称作稀疏性限制。推导过程如下[https://blog.csdn.net/pi9nc/article/details/27711441]：

变分自编码器(VAE)：与传统AE输出的隐藏层不同，其给隐藏层加了一个约束：迫使隐藏层产生满足高斯分布的变量，即均值趋于0，方差趋于1。与传统AE输出的隐藏层不同，其给隐藏层加了一个约束：迫使隐藏层产生满足高斯分布的变量，即均值趋于0，方差趋于1。

除了以下介绍的几种AE，还有其它比如Contractive Auto-Encoder、Marginalized DAE等。

代码实现卷积降噪自编码器

本代码使用fashion_mnist数据集，基于Keras实现。

加载Keras自带的fashion_mnist数据集，并对输入数据添加噪声。

from keras.datasets import fashion_mnist
import numpy as np

(x_train,_),(x_test,_)=fashion_mnist.load_data()
x_train=x_train.reshape(-1,28,28,1).astype('float32')/255.0
x_test=x_test.reshape(-1,28,28,1).astype('float32')/255.

f=0.5
#产生噪声并叠加到训练数据上 loc是均值，scale是方差
x_train_noisy=x_train+f*np.random.normal(loc=0.0,scale=1.0,size=x_train.shape)
x_test_noisy=x_test+f*np.random.normal(loc=0.0,scale=1.0,size=x_test.shape)
#限制加上噪声后的值为0-1
x_train_noisy=np.clip(x_train_noisy,0.,1.)
x_test_noisy=np.clip(x_test_noisy,0.,1.)

查看添加噪声后的效果。

%matplotlib inline
import matplotlib.pyplot as plt

n=10
plt.figure(figsize=(20,2))
for i in range(n):
    ax=plt.subplot(1,n,i+1)
    plt.imshow(x_test_noisy[i].reshape(28,28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()

2.定义网络。

from keras.layers import *
from keras.models import Model,load_model

#编码器
from keras.layers import *
from keras.models import Model,load_model
#编码器
inputs=Input(shape=(28,28,1))
x=Conv2D(32,(3,3),padding='same',activation='relu')(inputs)
x=MaxPooling2D((2,2),padding='same')(x)
x=Conv2D(32,(3,3),padding='same',activation='relu')(x)
vector=MaxPooling2D((2,2),padding='same')(x)
#解码器
x=Conv2D(32,(3,3),padding='same',activation='relu')(vector)
x=UpSampling2D((2,2))(x)
x=Conv2D(32,(3,3),padding='same',activation='relu')(x)
x=UpSampling2D((2,2))(x)
outputs=Conv2D(1,(3,3),padding='same',activation='sigmoid')(x)

model=Model(inputs,outputs)
model.summary()

3.编译并训练网络，使用adam优化器，使用mse作为误差函数。

from keras import losses
model.compile(optimizer='adam',loss=losses.mean_squared_error)
model.fit(x_train_noisy,x_train,
         epochs=100,
          batch_size=128,
          shuffle=True
         )
model.save('AutoEncoder_Mnist.h5')

4.测试效果

#测试
%matplotlib inline
from keras.models import Model,load_model
import matplotlib.pyplot as plt
aemodel=load_model('AutoEncoder_Mnist.h5')
output_imgs=aemodel.predict(x_test_noisy)
n=10
count=0
plt.figure(figsize=(20,16))
for j in range(4):
    for i in range(n):
        ax=plt.subplot(8,n,j*2*n+i+1)#获取子图
        plt.imshow(x_test_noisy[count].reshape(28,28))
        plt.gray()
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)
        ax=plt.subplot(8,n,j*2*n+i+1+n)
        plt.imshow(output_imgs[count].reshape(28,28))
        plt.gray()
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)
        
        count+=1
    
    
plt.show()