自编码器Auto-Encoder

主要参考知乎：

https://www.zhihu.com/question/41490383

简介

自编码器可以理解成一个试图还原原始数据输入的系统。

它也是一种神经网络，他的输入和输出是一致的，它借助稀疏编码的思想，目标是使用稀疏的一些高阶特征重新组合来重构自己。

• 特征：期望输入/输出一致；期望使用高阶特征来重构自己，而不是简单的复制

• 主要论文：hinton-《reducing the dimensionality of data with neural networks》-使用自编码器对数据进行降维；

                 hinton提出的深度信念网络（DBN）：我们可能很难直接训练很深的网络结构，但是可以使用无监督的逐层训练提取特征，将网络的权重初始化到一个比较好的位置，辅助后面的监督训练，逐层的无监督训练和autoencoder的思想非常相似。

• 自编码器的目标：是让输出能和原始输入一致，相当于学习一个恒等式y=x,自编码器的输入节点和输出节点的数量是一致的，但是如果单纯的复制输入是毫无意义的，自编码器希望用少量的稀疏高阶特征来重构输入。

编码器模型如上所示，encoder是编码器，decoder是解码器，也就是对输入信号进行某种变换，由x得到y，解码器将编码y转换成x/,

数学方式表达为，y=f(x),  x/=g(y)=g(f(x))，

自编码器的作用是让输出x/尽可能的去复现输入x，但是不可能将f和g做成恒等映射。

自编码器的实现方式

人们通常对数据进行如下的约束：

1. 限制中间隐含层的节点数量，假设输入节点和输出节点都为n，中间隐含层节点为m。

• 如果m<n，这就相当于一个数据降维的过程，如果两层之间的变化均为线性变化，并且监督训练的误差为二次型误差，该网络等价于PCA（主成分分析）；
• 如果m>n,隐含层的节点数量大于输入层的节点数量，隐含层中存在大量维度为0,未被激活,这就是“稀疏自编码器”，稀疏的表达意味着系统在进行特征的选择，找到大量维度中真正重要的维度；

1. 给数据中加入噪声，Denoising AutoEncoder（去噪自编码器），从噪声中学习数据的特征，去噪自编码器最常使用的噪声是家性高斯噪声(AGN)或者随即遮挡噪声信号（Masking nois）；

对于自编码器，我们关心的不是输出，而是中间隐含层的编码，也就是输入到编码的映射，可以理解成编码是对输入的特征提取，而且是自己学出来的特征，这也是深度学习的核心之一。

堆叠自编码器（stacked Auto-Encoder，SAE）的实现方式

对于单个自编码器的结构是：

输入--隐含层--输出，当训练完成后，一般将输出层去掉，因为输出层只是为了进行监督训练的需要，但并不是需要的信息，输入到隐含层的映射才是需要的特征提取过程，当完成一个自编码器训练之后，将隐含层的输出当作下一个自编码器的输入同样是可行的，这就是堆叠自编码器，结构如下图所示。

整个结构是逐层训练实现的，先从得到第一层结构，之后依次进行，得到下一层结构，并最终实现这个堆叠结构，整个过程就像一层层搭积木，没有下层，上层是无法实现的，这就是“逐层非监督预训练”layer-wise unsuperwised pre-training,也是深度学习兴起的核心技术。

自编码器的各种形式

对于稀疏自编码器，详细的在网址------自编码算法和稀疏性

关于降噪自编码器Pascal Vincent的论文Stacked Denoising Autoencoders: Learning Useful Representations  in a deep network with a local Denoising criterion

去噪自编码器代码实现-python（tf实现）

import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
import input_data


def xavier_init(fan_in, fan_out, constant=1):
    low = -constant * np.sqrt(6 / (fan_in + fan_out))
    high = constant * np.sqrt(6 / (fan_in + fan_out))
    return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)


class AdditiveGaussianNoiseAutoencoder(object):
    def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus, optimizer=tf.train.AdamOptimizer(),
                 scale=0.1):
        self.n_input = n_input
        self.n_hidden = n_hidden
        self.transfer = transfer_function
        self.scale = tf.placeholder(tf.float32)
        self.training_scale = scale
        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        self.hidden = self.transfer(
            tf.add(tf.matmul(self.x + scale * tf.random_normal((n_input,)), self.weights['w1']), self.weights['b1']))
        self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])

        # cost
        self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
        self.optimizer = optimizer.minimize(self.cost)

        init = tf.global_variables_initializer()
        self.sess = tf.Session()
        self.sess.run(init)

    def _initialize_weights(self):
        all_weights = dict()
        all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden))
        all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden], dtype=tf.float32))
        all_weights['w2'] = tf.Variable(tf.zeros([self.n_hidden, self.n_input], dtype=tf.float32))
        all_weights['b2'] = tf.Variable(tf.zeros([self.n_input], dtype=tf.float32))
        return all_weights

    def partial_fit(self, X):
        cost, opt = self.sess.run((self.cost, self.optimizer), feed_dict={self.x: X, self.scale: self.training_scale})
        return cost

    def cal_total_cost(self, X):
        return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale})

    def transform(self, X):
        return self.sess.run(self.hidden, feed_dict={self.x: X, self.scale: self.training_scale})

    def generate(self, hidden=None):
        if hidden is None:
            hidden = np.random.normal(size=self.weights['b1'])
        return self.sess.run(self.reconstruction, feed_dict={self.hidden: hidden})

    def resconstruct(self, X):
        return self.sess.run(self.reconstruction, feed_dict={self.x: X, self.scale: self.training_scale})

    def getweights(self):
        return self.sess.run(self.weights['w1'])

    def getbiases(self):
        return self.sess.run(self.weights['b1'])


mnist = input_data.read_data_sets('MNIST_DATA', one_hot=True)


def standard_scale(X_train, X_test):
    preprocessor = prep.StandardScaler().fit(X_train)
    X_train = preprocessor.transform(X_train)
    X_test = preprocessor.transform(X_test)
    return X_train, X_test


def get_random_block_from_data(data, batch_size):
    start_index = np.random.randint(0, len(data) - batch_size)
    return data[start_index:(start_index + batch_size)]


X_train, X_test = standard_scale(mnist.train.images, mnist.test.images)

n_samples = int(mnist.train.num_examples)
training_epochs = 20
batch_size = 128
display_step = 1

autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784, n_hidden=200, transfer_function=tf.nn.softplus,
                                               optimizer=tf.train.AdamOptimizer(learning_rate=0.001), scale=0.01)

for epoch in range(training_epochs):
    avg_cost = 0.
    total_batch = int(n_samples / batch_size)
    # Loop over all batches
    for i in range(total_batch):
        batch_xs = get_random_block_from_data(X_train, batch_size)

        # Fit training using batch data
        cost = autoencoder.partial_fit(batch_xs)
        # Compute average loss
        avg_cost += cost / n_samples * batch_size
        # Display logs per epoch step
        if epoch % display_step == 0:
            print('Epoch', '%4d' % (epoch + 1), 'cost=', '{:.9f}'.format(avg_cost))
print('Total cost:' + str(autoencoder.cal_total_cost(X_test)))