TensorFlow实现自编码器

TensorFlow实现自编码器

在监督学习中，训练样本是有类别标签的。现在假设我们只有一个没有带类别标签的训练样本集合，其中。顾名思义，自编码器（AutoEncoder），即可以使用自身的高阶特征编码自己。

1 自编码器原理

自编码器，其实也是一种神经网络，只是它的输入和输出是一致的，有关神经网络的基础，可以参考我之前的博文：http://blog.csdn.net/louishao/article/details/54914601

自编码器的网络结构图

对于自编码，输入层的神经元数等于输出层的神经元数。

其目标是使用稀疏的一些高阶特征重新组合来重构自己。因此，它的特点是：第一，期望输入/输出一致；第二，希望使用高阶特征来重构自己，而不只是复制像素点。

对于自编码器，输入的节点和输出的节点相同，但如果只是单纯地逐个复制输入节点则没有意义，自编码器通常是希望使用少量稀疏的高阶特征来重构输入，所以，我们加入几种限制。

（1）如果限制中间隐含层节点的数量，比如让中间隐含层节点的数量小于输入/输出节点的数量，就相当于一个降维的过程。如果再给中间隐含层的权重加一个L1的正则，则可根据惩罚系数控制隐含节点的稀疏程度。

（2）如果给数据加入噪声，那么就是Denoising AutoEncoder(去噪自编码器)，我们将从噪声中学习出数据的特征。同样，我们不可能完全复制节点，完全复制并不能去除我们添加的噪声，无法完全复原数据。所以，唯有学习数据频繁出现的模式和结构，将无规律的噪声略去，才可以复原数据。

本算法，实现的是一种具有代表性的去噪自编码器。实际就是，将mnist数据集中的训练集和测试集数据进行加噪，然后使用神经网络构造自编码器进行去噪。

2 算法流程

A 加载mnist训练集和测试集，只加载特征，不加载标签。

B 对数据进行标准化处理

C 初始化参数

这里的初始化和之前的有所不同，这里考虑到深度学习网络的初始化额度问题，程序中使用的是Xavier初始化器。

D 构造网络

输入层节点784个，隐含层节点200个，输出层节点和输入一样。同时要对输入数据进行加噪处理。

E 定义代价函数，进行迭代优化

F 进行实验，可视化结果对比

3 编程实现

#-*- coding:utf-8 -*-
import numpy as np
import os
import sklearn.preprocessing as prep
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
# 对于深度学习，权重初始值不能设得太小，也不能太大，而Xaiver初始化器则是用于
# 恰好设置初始值用的
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)

def plot_image(image):
    plt.imshow(image.reshape((28,28)),interpolation='nearest',cmap='binary')
    plt.show()

# 下面是去噪自编码器的class
class AdditiveGaussianAutoencoder(object):
    def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus,optimizer=tf.train.AdamOptimizer(),scale=1.0):
        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._initalize_weights()
        self.weights = network_weights

        # 定义网络结构
        self.x = tf.placeholder(tf.float32,[None,self.n_input]) # 输入层
        self.noisex = self.x+scale*tf.random_normal((n_input,))  # 加入噪声的输入图像
        # 下面是给输入的数据加入了噪声
        self.hidden = self.transfer(tf.add(tf.matmul(self.noisex,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 _initalize_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以及执行一步训练的函数
    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 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:
            hidden = np.random.normal(size=self.weights["b1"])
        return self.sess.run(self.reconstruction,feed_dict={self.hidden:hidden})

    def reconstrdata(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'])

    # 可视化对比原输入图像和加入噪声后的图像
    def plot_noiseimg(self,img,show_comp=True):
        self.noise = self.sess.run(tf.random_normal((self.n_input,)))
        noiseimg = img + self.training_scale*self.noise
        plot_image(noiseimg)
        if show_comp:
            plt.subplot(121)
            plt.imshow(img.reshape((28, 28)), interpolation='nearest', cmap='binary')
            plt.subplot(122)
            plot_image(noiseimg)

# 定义一个对训练、测试数据进行标准化（0均值，且标准差为1的分布）处理的函数。
def standard_scale(X_train,X_test):
    preprocessor = prep.StandardScaler().fit(X_train) # 这句是保证训练、测试数据都使用完全相同Scalar
    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)]

if __name__ == '__main__':
    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 = 20
    batch_size = 128
    display_step = 1

    image0 = mnist.train.images[2]
    #img = X_train[2]

    # scale是噪声系数
    autoencoder =AdditiveGaussianAutoencoder(n_input=784,
                                             n_hidden=200,
                                             transfer_function=tf.nn.softplus,
                                             optimizer=tf.train.AdamOptimizer(learning_rate=0.001),
                                             scale=0.1)
    #plot_image(img)
    autoencoder.plot_noiseimg(image0)
    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)
            #output = autoencoder.reconstrdata(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(output)
    #with tf.Session() as sess:
     #   sess.run(tf.global_variables_initializer())
      #  afterimg = autoencoder.reconstruction(image0)
       # plot_image(afterimg)
    #print(autoencoder.reconstrdata(X_train))
    reimg = autoencoder.reconstrdata(X_train)[2]
    plot_image(reimg)
    print("Total cost:"+str(autoencoder.calc_total_cost(X_test)))

4 实验结果

原图像（左）和加噪后的图像（右）如下图所示：

实验截图:

最终重构的图像：

至此，去噪自编码器的TensorFlow实现就全部结束了。从实现的过程中，自编码器和一个单隐含层的神经网络差不多，只不过在数据输入时做了标准化，并加上了一个高斯噪声，同时，并不是对数据进行分类。