tensorflow 实现基本AutoEncoder，降噪自编码器

Auto-Encoder(AE)是20世纪80年代晚期提出的，它是一种无监督学习算法，使用了反向传播算法，让目标值等于输入值。基本的AE可视为一个三层神经网络结构：一个输入层、一个隐藏层和一个输出层，其中输出层与输入层具有相同的规模。

AE最初是作为一个降维手段来进行的，要是编码器那里没有使用非线性部分，那么就可以等价为PCA算法来使用。（初始的维数大于编码器输出的维数的时候）

而现在编码器的输出维数大于输入的维数（over-complete setting），获取更高维，更加有意义的表示。

AE有一个问题就是要是直接对上面的损失函数（平方误差或者交叉熵）进行训练的话，很可能就会得到一个恒等函数。解决此问题的常用的一些方法，有在损失函数里面引入稀疏性（sparse AE），或者在网络中引入随机性（如RBM，Denoising AE）。

 

标准自编码器（在基本的自编码器里面引入正则化项就行，一般是L1或者L2正则化项。）

标准自编码器实则是对权重的设置提出要求，限制权重，避免过大

最左边的是一个输入层，中间是隐藏层，最右边是输出层，输出层的神经元数量完全等于输入层神经元的数量。隐藏层的神经元数量少于输出层。 自编码网络的作用是，将输入样本压缩到隐藏层，再在输出端重建样本。其目标是使输出和输入之间尽量的小。

神经网络权重矩阵的初始化，经验之谈，xaviar initialization。如果权重初始化得太小，那信号在每层间传递是逐渐缩小而难以产生作用，但是如果权重初始化得太大，那信号将在每层间逐渐放大并且导致发散和失效。xaviar initialization就是让均值满足为0，方差是

损失函数：

实现基本自编码器

# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
import Utils

class Autoencoder(object):

    def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus, optimizer = tf.train.AdamOptimizer()):
        # softplus: ln(exp(x) + 1) 它的倒数就是sigmoid函数，它限制左边始终大于0，右边没有限制
        self.n_input = n_input
        self.n_hidden = n_hidden
        self.transfer = transfer_function

        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        # n_input 指的是输入的维度
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        self.hidden = self.transfer(tf.add(tf.matmul(self.x, self.weights['w1']), self.weights['b1']))
        # 将隐藏层的输出限制在大于0的空间里面，
        # 这就是一个非线性环节，只限制左端，并没有限制右端
        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.sub(self.reconstruction, self.x), 2.0))
        # 做减法，然后平方，这里使用的是重构误差最小，使用均方误差
        self.optimizer = optimizer.minimize(self.cost)

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


    def _initialize_weights(self):
        all_weights = dict()
        all_weights['w1'] = tf.Variable(Utils.xavier_init(self.n_input, self.n_hidden))
        # 在初始化的时候，就只是第一个权重矩阵是赋予一些随机值，其他的都是赋予全0矩阵
        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})
        return cost

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

    def transform(self, X):
        # 这个函数在整个自编码器训练好了之后，使用它可以将原始数据进行编码，得到的结果就是编码形式
        return self.sess.run(self.hidden, feed_dict={self.x: X})

    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 reconstruct(self, X):
        # 先进行编码，然后进行解码，得到的最后结果
        return self.sess.run(self.reconstruction, feed_dict={self.x: X})

    def getWeights(self):
        # 得到编码用的权值矩阵
        return self.sess.run(self.weights['w1'])

    def getBiases(self):
        # 得到编码器的偏重值
        return self.sess.run(self.weights['b1'])

降噪自编码器

emptyclass 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
        # n_input,n_hidden都是输入和隐藏层的维度
        self.transfer = transfer_function
        self.scale = tf.placeholder(tf.float32)
        self.training_scale = scale
        # scale 就是一个标量
        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        # none不给定具体的值，它由输入的数目来决定
        self.hidden = self.transfer(tf.add(tf.matmul(self.x + scale * tf.random_normal((n_input,)),
                self.weights['w1']),
                self.weights['b1']))
        # 在输入的时候，在输入的数据上加上一些高斯噪声
        # tf.random_normal((n_input,)) 默认
        # 给的是一个均值为0，标准差是1的正态分布的随机数

        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.sub(self.reconstruction, self.x), 2.0))
        self.optimizer = optimizer.minimize(self.cost)

        init = tf.initialize_all_variables()
        self.sess = tf.Session()
        self.sess.run(init)
        
        
        
        
class MaskingNoiseAutoencoder(object):
    # 将有些数据直接忽略掉，即直接将一部分数据直接赋予0
    def __init__(self, n_input, n_hidden, transfer_function = tf.nn.softplus, optimizer = tf.train.AdamOptimizer(),
                 dropout_probability = 0.95):
        self.n_input = n_input
        self.n_hidden = n_hidden
        self.transfer = transfer_function
        self.dropout_probability = dropout_probability
        self.keep_prob = tf.placeholder(tf.float32)

        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        # 直接在输入数据上使用dropout来实现它，这样就实现了masking noise
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        self.hidden = self.transfer(tf.add(tf.matmul(tf.nn.dropout(self.x, self.keep_prob), 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.sub(self.reconstruction, self.x), 2.0))
        self.optimizer = optimizer.minimize(self.cost)

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