Tensorflow实现自编码器--代码参考自《Tensorflow实战》

在调通这段代码前要做以下事情：

1. 安装tensorflow（windows：在Python安装包的scripts文件夹下，pip install tensorflow。linux：进入终端，然后输入pip install tensorflow）

2. 安装sklearn（用同样的方法，pip install sklearn）

3. 安装numpy（如果安装了anaconda，系统会自带numpy，就不需要安装了）

完整代码如下：

# -*- coding: utf-8 -*-
"""
Created on Wed Dec 27 08:40:47 2017

@author: ndscbigdata2
"""

import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#定义一个生成初始权重的函数
def xavier_init(fan_in,fan_out,constant=1):#fan_in,fan_out分别是输入输出节点的数量
low=-constant*np.sqrt(6.0/(fan_in+fan_out))
high=-low
return tf.random_uniform((fan_in,fan_out),minval=low,maxval=high,dtype=tf.float32)

#定义一个去噪自编码的class
class AdditiveGaussianNoiseAutoencoder(object):

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

def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus,optimizer=tf.train.AdamOptimizer(),scale=0.1):
#参数分别代表实例，输入变量数，隐层节点数，隐层激活函数默认为softplus，优化器默认为Adam，搞死噪声系数默认为0.1
#__init__这种加了两个下划线的函数，表示只能在类内引用。
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

#计算各层值
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.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'])
#self.reconstruction = tf.add( tf.matmul( self.hidden, self.weights['w2'] ), self.weights['b2'] )

self.cost=0.5*tf.reduce_sum(tf.pow(tf.subtract(self.x,self.reconstruction),2.0))
#self.cost = 0.5 * tf.reduce_sum( tf.pow( tf.subtract( self.reconstruction, self.x ), 2 ) )

self.optimizer=optimizer.minimize(self.cost)
#self.optimizer = optimizer.minimize( self.cost )

#初始化
init=tf.global_variables_initializer()
self.sess=tf.Session()
self.sess.run(init)

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})

def transform(self,X):
return self.sess.run(self.hidden,feed_dict={self.x:X,self.scale:self.training_scale})

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})

def reconstruct(self,X):
return self.sess.run(self.reconstruction,feed_dict={self.x:X,self.scale:self.training_scale})

def getWeights(self):
return self.sess.run(self.weights['w1'])

def getBiases(self):
return self.sess.run(self.weights['b1'])

MNIST_data_folder="C:\\Users\\ndscbigdata2\\Anaconda3\\Scripts\\MNIST_data"
mnist=input_data.read_data_sets(MNIST_data_folder,one_hot=True)
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

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]

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#每隔一轮就显示一次损失cost

autoencoder=AdditiveGaussianNoiseAutoencoder(n_input=784,n_hidden=200,transfer_function=tf.nn.softplus,optimizer=tf.train.AdamOptimizer(learning_rate=0.001),scale=0.01)
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)))


如果能成功运行，应该显示以下结果：