TensorFlow 实现堆叠自编码器ASE

TensorFlow 实现堆叠自编码器ASE

自编码器（Auto Encoder）

神经网络常常用于分类，通过定义一个目标函数衡量输出与目标值之间的差异，然后通过调整系统的参数使系统尽量拟合训练数据．
而对每一层神经网络来说，前一层的输出都是可看做未加工的初始数据，而这一层则是对初始数据进行加工组织的更高阶的特征．
设由无类别标签的训练样本集合 ｛x(1)　x(2)　x(3)　…｝,x(i)∈Rn
自编码神经网络是一种无监督学习算法，使用反向传播算法，并让目标值等于输出值．
自编码神经网络结构如图：
（输入数据为 x, 隐藏层为 h）

实际上，当训练结束后，输出层已经没有意义了．网络可以学习出一种特征变换h，即原始输入数据的另一种表示．
此时，根据隐藏层维度和输入数据维度的大小可以分为以下两种情况：

1. 隐藏层维度小于输入数据维度 即从 x→h x→h的变换是一种降维操作，网络试图用更小的维度去表示原始数据且尽量不损失数据信息．
2. 隐藏层维度大于输入数据维度
   当隐藏层神经元数量较多时，通过给神经元加入稀疏性限制(使h的表达尽量稀疏，即有大量的维度为0未被激活)来发现输入数据中的结构．此时，编码器为稀疏编码器．

堆叠自编码器（ASE）

可以将 h h再当作原始数据信息训练一个新的自编码器，得到新的特征表达．即堆叠自编码器(Stacked Auto-Encoder)或栈式自编码器．

整个网络的训练是逐层进行的即逐层非监督预训练(layer-wise unsuperwised pre-training).

TensorFlow实现自编码器

下载MNIST数据集：lecun主页
将数据下载到文件夹Mnist_data下：

代码如下：

import tensorflow as tf
import sklearn.preprocessing as prep
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

# Xaiver初始化器保证权重初始化的不大不小均值为0方差为(2/(输入节点总数+输出节点总数))的均匀分布或高斯分布
def xavier_init(fan_in, fan_out, constant = 1):
    low = -constant * np.sqrt(6.0/(fan_in + fan_out))
    high = constant * np.sqrt(6.0/(fan_in + fan_out))
    # 使用均匀分布
    return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)

# 去噪编码class
class AdditiveGaussianNoiseAutoencoder(object):
    # 隐含层激活函数默认为softplus
    # 优化器,默认为Adam
    def __init__(self, n_input, n_hidden, transer_function=tf.nn.softplus,
                 optimizer=tf.train.AdamOptimizer(), scale=0.1):
        # 输入变量数
        self.n_input = n_input
        # 隐含节点数
        self.n_hidden = n_hidden
        self.transfer = transer_function
        self.scale = tf.placeholder(tf.float32)
        self.traning_scale = scale
        # 参数初始化
        network_weights = self.__initialize_weights__()
        self.weights = network_weights

        # 定义网络结构
        # 为输入x创建一个维度为n_input的占位符
        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'])

        # 定义自编码器的损失函数
        # 计算输入输出差的平方的和
        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()
        # w1使用xavier_init函数初始化：
        # 传入输入节点数和隐含层节点数,返回一个比较适合于softplus等激活函数的权重初始分布
        all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden))
        # b1 w2 b2全部置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):
        # 用一个batch数据进行训练并返回当前的损失
        cost, opt = self.sess.run((self.cost, self.optimizer),
                                  feed_dict={self.x: X, self.scale: self.traning_scale})
        return cost

    # 只求损失cost,在测试集上对模型性能进行评测
    def calc_total_cost(self, X):
        return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.traning_scale})

    # 返回自编码器隐含层的输出结果
    def transform(self, X):
        # 提供一个接口获取抽象后的特征,隐含层的主要功能即学习出数据中的高阶特性
        return self.sess.run(self.hidden, feed_dict={self.x: X, self.scale: self.traning_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})

    # 包括transform和generate两部分,输入原数据输出也是原数据
    def reconstruct(self, X):
        return self.sess.run(self.reconstruction, feed_dict={self.x: X, self.scale: self.training_scale})

    # 获取隐含层的权重w1
    def getWeights(self):
        return self.sess.run(self.weights['w1'])

    # 获取隐含层的偏执系数b1
    def getBiases(self):
        return self.sess.run(self.weights['b1'])

# 标准化处理函数：将数据变为均值为0标准差为1的分布
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

# 随机抽样batch_size个数据
def get_random_block_from_data(data, batch_size):
    # 随机选择一个0到len(data) - batch_size之间的随机整数
    start_index = np.random.randint(0, len(data) - batch_size)
    # 顺序选择一个batch_size大小的数据
    return data[start_index:(start_index + batch_size)]


# 读取Mnist_data文件夹下的MNIST数据集
mnist = input_data.read_data_sets('Mnist_data', one_hot=True)

# 对训练集测试集进行标准化变换
X_train, X_test = standard_scale(mnist.train.images, mnist.test.images)
# 总训练样本数
n_samples = int(mnist.train.num_examples)
# 最大轮数
training_epochs = 30
batch_size = 128
# 每隔1轮显示一次损失
display_step = 1
# 优化器optimizer为Adam且学习速率为0.001,噪声系数设为0.01
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784,
              n_hidden=200, transer_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)
    for i in range(total_batch):
        # 随机抽样batch_size个数据
        batch_xs = get_random_block_from_data(X_train, batch_size)
        # 计算当前的损失
        cost = autoencoder.partial_fit(batch_xs)
        # 将当前损失整合到avg_cost
        avg_cost += cost/n_samples * batch_size

    if epoch % display_step == 0:
        print "Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)

# 检测误差
print "Total cost:" + str(autoencoder.calc_total_cost(X_test))

输出：

Extracting Mnist_data/train-images-idx3-ubyte.gz
Extracting Mnist_data/train-labels-idx1-ubyte.gz
Extracting Mnist_data/t10k-images-idx3-ubyte.gz
Extracting Mnist_data/t10k-labels-idx1-ubyte.gz

Epoch: 0001 cost= 18393.803394318
Epoch: 0002 cost= 12056.212395455
Epoch: 0003 cost= 11560.195284091
Epoch: 0004 cost= 9874.588271023
Epoch: 0005 cost= 9680.366493750
Epoch: 0006 cost= 8302.406408523
Epoch: 0007 cost= 9170.771014205
Epoch: 0008 cost= 9230.874527273
Epoch: 0009 cost= 8316.486203977
Epoch: 0010 cost= 9159.939965909
Epoch: 0011 cost= 8616.586401136
Epoch: 0012 cost= 8459.991118182
Epoch: 0013 cost= 7664.576960227
Epoch: 0014 cost= 8489.886681250
Epoch: 0015 cost= 7643.553435795
Epoch: 0016 cost= 8587.016578409
Epoch: 0017 cost= 7797.239460795
Epoch: 0018 cost= 7596.627213068
Epoch: 0019 cost= 7543.282728409
Epoch: 0020 cost= 7634.373622159
Epoch: 0021 cost= 8546.334438636
Epoch: 0022 cost= 7568.472099432
Epoch: 0023 cost= 8288.032989773
Epoch: 0024 cost= 7934.257227273
Epoch: 0025 cost= 7766.447797727
Epoch: 0026 cost= 7191.460046591
Epoch: 0027 cost= 7610.152782386
Epoch: 0028 cost= 7378.358159091
Epoch: 0029 cost= 7491.907940909
Epoch: 0030 cost= 8503.457048864
Total cost:637764.0

参考：https://blog.csdn.net/akadiao/article/details/78471209