Tensorflow实现自动编码器

最近在帮助师兄完成毕设，涉及到了tensorflow和机器学习的知识，下面的代码描述了自动编码器编码解码的过程；同时，实现了模型的保存和数据替换的过程。首先，利用true.txt中的数据进行模型的训练，然后在利用false的数据进行测试，比较两次cost的差值。具体代码如下：

"""
Created on Wed Jan 23 12:29:56 2019

@author: 肖俊怡
"""



import tensorflow as tf
#import matplotlib.pyplot as plt
import numpy as np

#from tensorflow.examples.tutorials.mnist import input_data
#mnist = input_data.read_data_sets("MNIST_data/", one_hot=False)

train_data = np.loadtxt("true.txt")
#train_label = np.loadtxt("true.txt")
test_data = np.loadtxt("true.txt")
#test_label = np.loadtxt("true.txt")
#test_xs = np.ones((test_data.shape[0],28*28))
#test_ys = np.ones((test_data.shape[0],2))
#test_ys = test_label


#学习率决定了参数移动到最优值的速度快慢
learning_rate = 0.01
#指数据集中每一个样本都跑过一遍
training_epochs = 1
#每次选取的样本个数
batch_size = 200

display_step = 1
n_input = 18
#分配必要的内存，占位；类型：float；行数不定，列数为784
X = tf.placeholder("float", [None, n_input])
 
n_hidden_1 = 16
n_hidden_2 = 8
n_hidden_3 = 4
n_hidden_4 = 2
#设置权重值，并存入字典#从截断的正态分布中输出随机值
weights = {
    'encoder_h1': tf.Variable(tf.truncated_normal([n_input, n_hidden_1],)),
    'encoder_h2': tf.Variable(tf.truncated_normal([n_hidden_1, n_hidden_2],)),
    'encoder_h3': tf.Variable(tf.truncated_normal([n_hidden_2, n_hidden_3],)),
    'encoder_h4': tf.Variable(tf.truncated_normal([n_hidden_3, n_hidden_4],)),
    'decoder_h1': tf.Variable(tf.truncated_normal([n_hidden_4, n_hidden_3],)),
    'decoder_h2': tf.Variable(tf.truncated_normal([n_hidden_3, n_hidden_2],)),
    'decoder_h3': tf.Variable(tf.truncated_normal([n_hidden_2, n_hidden_1],)),
    'decoder_h4': tf.Variable(tf.truncated_normal([n_hidden_1, n_input],)),
}
#设置偏重值，并存入字典，从正态分布中生成随机值
biases = {
    'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
    'encoder_b3': tf.Variable(tf.random_normal([n_hidden_3])),
    'encoder_b4': tf.Variable(tf.random_normal([n_hidden_4])),
    'decoder_b1': tf.Variable(tf.random_normal([n_hidden_3])),
    'decoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
    'decoder_b3': tf.Variable(tf.random_normal([n_hidden_1])),
    'decoder_b4': tf.Variable(tf.random_normal([n_input])),
}
#进行函数运算，构建编码器
def encoder(x):
    layer_1 = tf.nn.relu(tf.add(tf.matmul(x, weights['encoder_h1']),
                                   biases['encoder_b1']))
    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
                                   biases['encoder_b2']))
    layer_3 = tf.nn.relu(tf.add(tf.matmul(layer_2, weights['encoder_h3']),
                                   biases['encoder_b3']))
    # 为了便于编码层的输出，编码层随后一层不使用激活函数
    layer_4 = tf.add(tf.matmul(layer_3, weights['encoder_h4']),
                                    biases['encoder_b4'])
    return layer_4
#构建解码器 
def decoder(x):
    layer_1 = tf.nn.relu(tf.add(tf.matmul(x, weights['decoder_h1']),
                                   biases['decoder_b1']))
    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
                                   biases['decoder_b2']))
    layer_3 = tf.nn.relu(tf.add(tf.matmul(layer_2, weights['decoder_h3']),
                                biases['decoder_b3']))
    layer_4 = tf.nn.relu(tf.add(tf.matmul(layer_3, weights['decoder_h4']),
                                biases['decoder_b4']))
    return layer_4
#构建模型
encoder_op = encoder(X)
decoder_op = decoder(encoder_op)

#预测 
y_pred = decoder_op
y_true = X
 
#定义代价函数和优化器
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
 
with tf.Session() as sess:
    # tf.initialize_all_variables() no long valid from
    # 2017-03-02 if using tensorflow >= 0.12
    if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:
        init = tf.initialize_all_variables()
    else:
        init = tf.global_variables_initializer()
    
    
    sess.run(init)
  # 首先计算总批数，保证每次循环训练集中的每个样本都参与训练，不同于批量训练  
    train_writer = tf.summary.FileWriter("E://logs//train",sess.graph)
    total_batch = int(60000/batch_size)
    
    
#保存
    is_train=False
    saver=tf.train.Saver(max_to_keep=1)
    
    if is_train:       
        for epoch in range(training_epochs):
            start = 0
            for i in range(total_batch):
                batch_xs = batch_xs = np.ones((batch_size,18)) 
                j = 0               
                while j<batch_size:
                    batch_xs[j][:] = train_data[i*batch_size+j][:]#epoch*total_batch+
                    j = j+1
                start+=1
                #batch_ys =  np.ones((batch_size,2))
                # max(x) = 1, min(x) = 0
                _, c = sess.run([optimizer, cost], feed_dict={X: batch_xs})
                print("Epoch:", '%04d' % (i+1), "cost=", "{:.9f}".format(c))
            #if epoch % display_step == 0:
               # print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c))
        saver.save(sess,'ckpt/data1.ckpt',global_step=i+1)        
        print("Optimization Finished!")

        #encoder_result = sess.run(encoder_op, feed_dict={X: mnist.test.images})
        #encoder_result[:, 0]，encoder_result[:, 1]分别代表x,y的数据点
       # plt.scatter(encoder_result[:, 0], encoder_result[:, 1], c=mnist.test.labels)
        #设置颜色渐变条
       # plt.colorbar()
        #显示图像
       # plt.show()
        #sess.close()
    else:
        model_file=tf.train.latest_checkpoint('ckpt/')
        saver.restore(sess,model_file)
        #for epoch in range(training_epochs):
            #start = 0
        for i in range(60000):
            batch_xs = batch_xs = np.ones((1,18)) 
            #j = 0               
            #while j<batch_size:
            batch_xs[0][:] = test_data[i][:]#epoch*total_batch+
               # j = j+1
                    #start+=1
                    #batch_ys =  np.ones((batch_size,2))
                    # max(x) = 1, min(x) = 0
            c = sess.run(cost, feed_dict={X: batch_xs})
            print("Epoch:", '%04d' % (i+1), "cost=", "{:.9f}".format(c))
        #encoder_result = sess.run(encoder_op, feed_dict={X: mnist.test.images})
        #encoder_result[:, 0]，encoder_result[:, 1]分别代表x,y的数据点
        #plt.scatter(encoder_result[:, 0], encoder_result[:, 1], c=mnist.test.labels)
        #设置颜色渐变条
       # plt.colorbar()
        #显示图像
        #plt.show()
 #sess.close()       
                
                

刚刚入手，真的很难理解，以后有时间一定要仔细学习一下tensorflow，不过收获还是很多的~~~