1TensorFlow实现自编码器-1.3 TensorFlow实现降噪自动编码器--计算图美化

import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# Xvaier均匀初始化
# 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 AdditiveGaussianNoiseAutoencoder(object):
    # 在初始的数据中加入高斯噪声。在实现降噪自编码器的时候，
    # 只是在输入加进去的时候，在输入上加上高斯噪声就行
    # 其他的部分和基本自编码器一样
    # n_input：输入变量数；n_hidden：隐含层节点数；transfer_function：隐含层激活函数；optimizer：优化器；scale：高斯噪声系数；
    # Class内的scale声明成一个占位符placeholder，参数初始化则使用了接下来定义的_initialize_weights函数。我们只用了一个隐含层。
    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
        with tf.name_scope("RawInput"):
            self.x = tf.placeholder(tf.float32, [None, self.n_input])
        # none不给定具体的值，它由输入的数目来决定

        with tf.name_scope("NoiseAdder"):
            self.scale = tf.placeholder(tf.float32)
            self.noise_x = self.x + self.scale * tf.random_normal((n_input,))

        with tf.name_scope("Encoder"):
            self.hidden = self.transfer(tf.add(tf.matmul(self.noise_x,self.weights['w1']), self.weights['b1']))
        # 在输入的时候，在输入的数据上加上一些高斯噪声，
        # tf.random_normal((n_input,)) 默认给的是一个均值为0，标准差是1的正态分布的随机数。

        with tf.name_scope("Reconstruction"):
            self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])

        # x:一维的数量为n_input的placeholder；
        # 建立一个能提取特征的隐含层：
        # 先对输入x添加高斯噪声，即self.x + scale * tf.random_normal((n_input,))；
        #  再用tf.matmul()让被噪声污染的信号与隐藏层的权重相乘，再用tf.add()添加偏置；
        # 最后使用transfer()对加权汇总结果进行激活函数处理。

        # 经过隐藏层后，在输出层进行数据复原和重建操作，即建立reconstruction层，这时候就不需要激活函数了，
        # 直接将隐含层的输出self.hidden乘以输出层的权重w2再加上输出层的偏置b2。

        # cost
        with tf.name_scope("Loss"):
            self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))

        with tf.name_scope("Train"):
            self.optimizer = optimizer.minimize(self.cost)

        init = tf.global_variables_initializer()
        self.sess = tf.Session()
        self.sess.run(init)
        print("begin ti run session...")


    def _initialize_weights(self):
        all_weights = dict()
        all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden),name='weight1')
        # 在初始化的时候，就只是第一个权重矩阵是赋予一些随机值，其他的都是赋予全0矩阵
        all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden], dtype=tf.float32),name='bias1')
        all_weights['w2'] = tf.Variable(tf.zeros([self.n_hidden, self.n_input], dtype=tf.float32),name='weight2')
        all_weights['b2'] = tf.Variable(tf.zeros([self.n_input], dtype=tf.float32),name='bias2')
        return all_weights
    #变量初始化函数：创建一个dicts，包含所有Variable类型的变量w1，b1，w2，b2
    #隐藏层：w1用前面写的xavier_init函数初始化，传入输入节点数和隐含节点数，即可得到一个比较适合softplus等激活函数的初始状态，b1初始化为0

#产生一个AdditiveGaussianNoiseAutoencoder类的对象实例，调用tf.summary.FileWriter把计算图写入文件，使用TensorBoard查看
AGN_AC = AdditiveGaussianNoiseAutoencoder(n_input=784,n_hidden=200,transfer_function=tf.nn.softplus,
                                          optimizer=tf.train.AdamOptimizer(learning_rate=0.01),scale=0.01)

print('把计算图写入事件文件，在TensorBoard里面查看')
writer = tf.summary.FileWriter(logdir='logs',graph=AGN_AC.sess.graph)
writer.close()