堆叠降噪自编码器python代码基于TensorFlow1.0，已跑通

#coding:UTF-8
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

#创建降噪自编码器类
class Denosing_AutoEncoder（）:
    def __init__（selfn_hiddeninput_datacorruption_level=0.3）:
        self.W=None#输入层到隐含层的权重
        self.b=None#输入层到隐含层的偏置
        self.encode_r=None#隐含层的输出5
        self.layer_size=n_hidden#隐含层节点的个数
        self.input_data=input_data#输入样本
        self.keep_prob=1-corruption_level#特征保持不变的比例
        self.W_eval=None#权重W的值
        self.b_eval=None#偏置b的值

    #降噪自编码器的训练
    def fit（self）:
        #输入层节点的个数
        n_visible=（self.input_data）.shape[1]
        #输入一张图片用28*28=784的向量表示
        X=tf.placeholder（“float“[Nonen_visible]name=‘X‘）
        #用于将部分输入数据置为0
        mask=tf.placeholder（“float“[Nonen_visible]name=‘mask‘）
        #创建权重和偏置
        W_init_max=4*np.sqrt（6./（n_visible+self.layer_size））
        W_init=tf.random_uniform（shape=[n_visibleself.layer_size]minval=-W_init_maxmaxval=W_init_max）

        #编码器
        self.W=tf.Variable（W_initname=‘W‘）#784*500
        self.b=tf.Variable（tf.zeros（[self.layer_size]）name=‘b‘）#隐含层的偏置
        #解码器
        W_prime=tf.transpose（self.W）
        b_prime=tf.Variable（tf.zeros（[n_visible]）name=‘b_prime‘）
        tilde_X=mask*X#对输入样本加入噪声
        Y=tf.nn.sigmoid（tf.matmul（tilde_Xself.W）+self.b）#隐含层的输出
        Z=tf.nn.sigmoid（tf.matmul（YW_prime）+b_prime）#重构输出
        cost=tf.reduce_mean（tf.pow（X-Z2））#均方误差
        train_op=tf.train.GradientDescentOptimizer（0.01）.minimize（cost）#最小化均方误差

        trX=self.input_data
        #开始训练
        with tf.Session（） as sess:
            #初始化所有的参数
            tf.initialize_all_variables（）.run（）
            for i in range（30）:
                for startend in zip（range（0len（trX）128）range（128len（trX+1）128））:#len（trX）矩阵秩，start=0128256...end=128256...
                    input_=trX[start:end]#设置输入每次输入128个，分批操作
                    mask_np=np.random.binomial（1self.keep_probinput_.shape）#设置mask基于二项分布（npsize），当n=1时，为伯努利分布（0-1分布）
                    #开始训练
                    sess.run（train_opfeed_dict={X:input_mask:mask_np}）
                if i%5.0==0:#每隔5次输出一次mask=[11...1]时的loss
                    mask_np=np.random.binomial（11trX.shape）#此时mask尺寸大小与原来输入尺寸大小一致，因此是trX
                    print（“loss function at step %s is %s“%（isess.run（costfeed_dict={X:trXmask:mask_np}）））
            #保存好输入层到隐含层的参数
            self.W_eval=（self.W）.eval（）
            self.b_eval=（self.b）.eval（）
            mask_np=np.random.binomial（11trX.shape）
            self.encode_r=Y.eval（{X:trXmask:mask_np}）

    #取得降噪自编码器的参数
    def get_value（self）:
        return self.W_evalself.b_evalself.encode_r

#创建堆叠降噪自编码器类
class Stacked_Denosing_AutoEncoder（）:
    def __init__（selfhidden_listinput_data_trainX
                 input_data_trainYinput_data_validX
                 input_data_validYinput_data_testX
                 input_data_testYc