Tensorflow学习之实现自编码器

深度学习之Tensorflow实现自编码器
当拥有很多的标注数据时，可以训练一个深层的神经网络。但是没有标注的数据时，依然可以利用无监督的自编码器来提取特征。自编码器（AutoEncoder），顾名思义，即可以使用自身的高阶特征编码自己。自编码器其实也是一种神经网络，它的输入和输出是一致的，它借助稀疏编码的思想，目标是使用稀疏的一些高阶特征重新组合来重构自己。因此，它的特点非常明显：第一，期望输入／输出一致；第二，希望使用高阶特征来重构自己，而不只是复制像素点。
无监督的逐层训练，其思想和自编码器非常相似，后者的目标是让神经网络的输出能和原始输入一致，相当于学习一个恒等式y=x。自编码器通常希望使用少量稀疏的高阶特征来重构输入，所以可以加入几种限制。
（1）如果限制中间隐含层节点的数量，比如让中间隐含层节点的数量小于输入／输出节点的数量，就相当于一个降维的过程。此时已经不可能出现复制所有节点的情况，因为中间节点数小于输入节点数，那只能学习数据中最重要的特征复原，将可能不太相关的内容去除。此时，如果再给中间隐含层的权重加一个L1的正则，则可以根据惩罚系数控制隐含节点的稀疏程度，惩罚系数越大，学到的特征组合越稀疏，实际使用（非零权重）的特征数量越少。
（2）如果给数据加入噪声，那么就是Denoising AutoEncoder（去噪自编码器），我们将从噪声中学习出数据的特征。同时，我们也不可能完全复制节点，完全复制并不能去除我们添加的噪声，无法完全复原数据。所以唯有学习数据频繁出现的模式和结构，将无规律的噪声略去，才可以复原数据。
去噪自编码器中最常使用的噪声是加性高斯噪声，当然也可以使用Making Noidse,即随机遮挡的噪声。如果自编码器的隐含层只有一层，那么其原理类似于主成分分析PCA。
Hinton提出了基于深度信念网络（Deep Belief Network，DBN，由多层RBM堆叠而成），每个隐含层都是限制性玻尔兹曼机RBM，一种具有特殊连接分布的神经网络。DBN训练时，需要先对每两层间进行无监督的预训练，这个过程其实就相当于一个多层的自编码器，可以将整个网络的权重初始化到一个理想的分布。最后通过反向传播算法调整模型权重，这个步骤会使用经过标注的信息来做监督性的分类训练。简单地说，Hinton的思路就是先用自编码器的方法进行无监督的预训练，提取特征并初始化权重，然后使用标注信息进行监督式的训练。当然自编码器的作用不仅局限于给监督训练做预训练，直接使用自编码器进行特征提取和分析也是可以的。

Tensorflow实现去噪自编码器

'''先导入常用库NumPy，还有Scikit-learn中的preprocessing模块，这是一个对数据进行预处理的常用模块。'''
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
'''自编码器中会使用一种参数初始化方法xavier initialization，它的特点是会根据某一层网络的输入，输出节点数量自动调整最合适的分布。
    如果深度学习模型的权重初始化得太小，那信号将在每层间传递时逐渐缩小而难以产生作用，但如果权重初始化得太大，
    那信号将在每层间传递时逐渐放大并导致发散和失效。而Xaiver初始化器做的事情就是让权重被初始化得不大不小，正好合适。
    即让权重满足0均值，同时方差为2／（n（in）+n(out)），分布可以用均匀分布或者高斯分布。
    下面fan_in是输入节点的数量，fan_out是输出节点的数量。'''
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，包含一个构建函数_init_()：n_input（输入变量数），n_hidden（隐含层节点数），transfer_function（隐含层激活函数，默认为softplus）
    optimizer（优化器，默认为Adam），scale（高斯噪声系数，默认为0.1）。其中，class内的scale参数做成了一个占位符
    参数初始化则使用_initialize_weights函数。'''
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
#      接下来开始定义网络结构，为x创建一个维度为n_input的占位符，然后建立一个能提取特征的隐含层，先将输入x加上噪声，然后用tf.matmul将加了噪声的输入与隐含层的权重相乘
#      并使用tf.add加上隐含层的偏置，最后对结果进行激活函数处理。经过隐含层后，需要在输出层进行数据复原，重建操作。
        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'])
#      接下来定义自编码器的损失函数，这里使用平方误差作为损失函数，再定义训练操作作为优化器对损失进行优化，最后创建Session并初始化自编码器的全部模型参数。
        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
#      定义计算损失cost及执行一步训练的函数partial_fit。函数里只需让Session执行两个计算图的节点，分别是损失cost和训练过程optimizer，输入的feed_dict包括输入数据x，
#      以及噪声的系数scale。函数partial_fit做的就是用一个batch数据进行训练并返回当前的损失cost。
    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
#      下面为一个只求损失cost的函数，这个函数是在自编码器训练完毕后，在测试集上对模型性能进行评测时会用到的。
    def calc_total_cost(self,X):
        return self.sess.run(self.cost,feed_dict={self.x:X,self.scale:self.training_scale})
#      定义transform函数，返回自编码器隐含层的输出结果，它的目的是提供一个接口来获取抽象后的特征，自编码器的隐含层的最主要功能就是学习出数据中的高阶特征。
    def transform(self,X):
        return self.sess.run(self.hidden,feed_dict={self.x:X,self.scale:self.training_scale})
#      定义generate函数，将隐含层的输出结果作为输入，通过之后的重建层将提取到的高阶特征复原为原始数据
    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})
#      定义reconstruct函数，它整体运行一遍复原过程，包括提取高阶特征和通过高阶特征复原数据
    def reconstruct(self,X):
        return self.sess.run(self.reconstruction,feed_dict={self.x:X,self.scale:self.training_scale})
#      定义getWeights函数的作用是获取隐含层的权重w1
    def getWeights(self):
        return self.sess.run(self.weights['w1'])
#       定义getBiases函数则是获取隐含层的偏置系数b1
    def getBiases(self):
        return self.sess.run(self.weights['b1'])
#       下面使用定义好的自编码器在MINIST数据集上进行一些简单的性能测试
mnist=input_data.read_data_sets('MNIST_data',one_hot=True)
#       先定义一个对训练、测试数据进行标准化处理的函数，标准化即让数据变成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
#       再定义一个获取随机block数据的函数：取一个从0到len(data)-batch_size之间的随机整数，再以这个随机数作为block的起始位置，然后顺序取到一个batch size的数据。
#       需要注意的是，这属于不放回抽样，可以提高数据的利用效率
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)]
#       使用之前定义的standard_scale函数对训练集、测试机进行标准化变换
X_train,X_test=standard_scale(mnist.train.images,mnist.test.images)
#       下面定义几个常用参数，总训练样本数，最大训练的轮数(epoch)设为20，batch_size设为128，并设置每隔一轮(epoch)就显示一次损失cost
n_samples=int(mnist.train.num_examples)
training_epochs=20
batch_size=128
display_step=1
#       创建一个自编码器的实例，定义模型输入节点数n_input为784，自编码器的隐含层点数n_hidden为200，隐含层的激活函数transfer_function为softplus，优化器optimizer为Adam
#       且学习速率为0。001，同时将噪声的系数设为0.01
autoencoder=AdditiveGaussianNoiseAutoencoder(n_input=784,n_hidden=200,transfer_function=tf.nn.softplus,optimizer=tf.train.AdamOptimizer(learning_rate=0.001),scale=0.01)
#       下面开始训练过程，在每一轮(epoch)循环开始时，将平均损失avg_cost设为0，并计算总共需要的batch数（通过样本总数除以batch大小），在每一轮迭代后，显示当前的迭代数和这一轮迭代的平均cost。
for epoch in range(training_epochs):
    avg_cost=0.
    total_batch=int(n_samples/batch_size)
    for i in range(total_batch):
        batch_xs=get_random_block_from_data(X_train,batch_size)
        cost=autoencoder.partial_fit(batch_xs)
        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)))

结果：

/usr/local/Cellar/anaconda/bin/python /Users/new/Documents/JLIFE/procedure/python_tr/py_train/train1.py
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
2017-07-26 17:49:11.464223: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations.
2017-07-26 17:49:11.464239: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations.
2017-07-26 17:49:11.464243: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations.
2017-07-26 17:49:11.464247: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use FMA instructions, but these are available on your machine and could speed up CPU computations.
Epoch: 0001 cost= 19037.808818182
Epoch: 0002 cost= 11611.377697727
Epoch: 0003 cost= 10192.214673295
Epoch: 0004 cost= 9965.982854545
Epoch: 0005 cost= 9977.133357386
Epoch: 0006 cost= 9629.597717614
Epoch: 0007 cost= 9366.739615341
Epoch: 0008 cost= 9451.955646023
Epoch: 0009 cost= 8655.756353977
Epoch: 0010 cost= 9385.456911932
Epoch: 0011 cost= 8691.026454545
Epoch: 0012 cost= 7808.168955114
Epoch: 0013 cost= 8536.450017614
Epoch: 0014 cost= 8361.853073864
Epoch: 0015 cost= 8577.262535227
Epoch: 0016 cost= 9147.155342045
Epoch: 0017 cost= 8387.879208523
Epoch: 0018 cost= 8323.613027273
Epoch: 0019 cost= 8232.555606250
Epoch: 0020 cost= 8255.203377841
Total cost:660028.0

Process finished with exit code 0

实现一个去噪自编码器和实现一个单隐含层的神经网络差不多，只不过是在数据输入时做了标准化，并加上了一个高斯噪声，同时我们的输出结果不是数字分类结果，而是复原的数据，因此不需要用标注过的数据进行监督训练。自编码器作为一种无监督学习的方法，它与其它无监督学习的主要不同在于，它不是对数据进行聚类，而是提取其中最有用，最频繁出现的高阶特征，根据这些高阶特征重构数据。