深度学习之Tensorflow实现自编码器 当拥有很多的标注数据时，可以训练一个深层的神经网络。但是没有标注的数据时，依然可以利用无监督的自编码器来提取特征。自编码器（AutoEncoder），顾名思义，即可以使用自身的高阶特征编码自己。自编码器其实也是一种神经网络，它的输入和输出是一致的，它借助稀疏编码的思想，目标是使用稀疏的一些高阶特征重新组合来重构自己。因此，它的特点非常明显：第一，期望输入／输出一致；第二，希望使用高阶特征来重构自己，而不只是复制像素点。 无监督的逐层训练，其思想和自编码器非常相似，后者的目标是让神经网络的输出能和原始输入一致，相当于学习一个恒等式y=x。自编码器通常希望使用少量稀疏的高阶特征来重构输入，所以可以加入几种限制。 （1）如果限制中间隐含层节点的数量，比如让中间隐含层节点的数量小于输入／输出节点的数量，就相当于一个降维的过程。此时已经不可能出现复制所有节点的情况，因为中间节点数小于输入节点数，那只能学习数据中最重要的特征复原，将可能不太相关的内容去除。此时，如果再给中间隐含层的权重加一个L1的正则，则可以根据惩罚系数控制隐含节点的稀疏程度，惩罚系数越大，学到的特征组合越稀疏，实际使用（非零权重）的特征数量越少。 （2）如果给数据加入噪声，那么就是Denoising AutoEncoder（去噪自编码器），我们将从噪声中学习出数据的特征。同时，我们也不可能完全复制节点，完全复制并不能去除我们添加的噪声，无法完全复原数据。所以唯有学习数据频繁出现的模式和结构，将无规律的噪声略去，才可以复原数据。 去噪自编码器中最常使用的噪声是加性高斯噪声，当然也可以使用Making Noidse,即随机遮挡的噪声。如果自编码器的隐含层只有一层，那么其原理类似于主成分分析PCA。 Hinton提出了基于深度信念网络（Deep Belief Network，DBN，由多层RBM堆叠而成），每个隐含层都是限制性玻尔兹曼机RBM，一种具有特殊连接分布的神经网络。DBN训练时，需要先对每两层间进行无监督的预训练，这个过程其实就相当于一个多层的自编码器，可以将整个网络的权重初始化到一个理想的分布。最后通过反向传播算法调整模型权重，这个步骤会使用经过标注的信息来做监督性的分类训练。简单地说，Hinton的思路就是先用自编码器的方法进行无监督的预训练，提取特征并初始化权重，然后使用标注信息进行监督式的训练。当然自编码器的作用不仅局限于给监督训练做预训练，直接使用自编码器进行特征提取和分析也是可以的。
Tensorflow实现去噪自编码器
'''先导入常用库NumPy，还有Scikit-learn中的preprocessing模块，这是一个对数据进行预处理的常用模块。'''
import numpy
as np
import sklearn.preprocessing
as prep
import tensorflow
as tf
from tensorflow.examples.tutorials.mnist
import input_data
'''自编码器中会使用一种参数初始化方法xavier initialization，它的特点是会根据某一层网络的输入，输出节点数量自动调整最合适的分布。
如果深度学习模型的权重初始化得太小，那信号将在每层间传递时逐渐缩小而难以产生作用，但如果权重初始化得太大，
那信号将在每层间传递时逐渐放大并导致发散和失效。而Xaiver初始化器做的事情就是让权重被初始化得不大不小，正好合适。
即让权重满足0均值，同时方差为2／（n（in）+n(out)），分布可以用均匀分布或者高斯分布。
下面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，包含一个构建函数_init_()：n_input（输入变量数），n_hidden（隐含层节点数），transfer_function（隐含层激活函数，默认为softplus）
optimizer（优化器，默认为Adam），scale（高斯噪声系数，默认为0.1）。其中，class内的scale参数做成了一个占位符
参数初始化则使用_initialize_weights函数。'''
class AdditiveGaussianNoiseAutoencoder(object):
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
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.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.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 _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 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=input_data.read_data_sets(
'MNIST_data',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
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:",
'd' % (epoch +
1),
"cost=",
"{:.9f}".format(avg_cost))
print(
"Total cost:" + str(autoencoder.calc_total_cost(X_test)))
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107
结果：
/usr/local/Cellar/anaconda/bin/python /Users/
new/Documents/JLIFE/
procedure/python_tr/py_train/train1.py
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
2017-
07-
26 17:
49:
11.464223: W tensorflow/core/platform/cpu_feature_guard.cc:
45] The TensorFlow
library wasn
't compiled
to use SSE4
.2 instructions, but these are available
on your machine
and could speed up CPU computations.
2017-
07-
26 17:
49:
11.464239: W tensorflow/core/platform/cpu_feature_guard.cc:
45] The TensorFlow
library wasn
't compiled
to use AVX instructions, but these are available
on your machine
and could speed up CPU computations.
2017-
07-
26 17:
49:
11.464243: W tensorflow/core/platform/cpu_feature_guard.cc:
45] The TensorFlow
library wasn
't compiled
to use AVX2 instructions, but these are available
on your machine
and could speed up CPU computations.
2017-
07-
26 17:
49:
11.464247: W tensorflow/core/platform/cpu_feature_guard.cc:
45] The TensorFlow
library wasn
't compiled
to use FMA instructions, but these are available
on your machine
and could speed up CPU computations.
Epoch:
0001 cost=
19037.808818182
Epoch:
0002 cost=
11611.377697727
Epoch:
0003 cost=
10192.214673295
Epoch:
0004 cost=
9965.982854545
Epoch:
0005 cost=
9977.133357386
Epoch:
0006 cost=
9629.597717614
Epoch:
0007 cost=
9366.739615341
Epoch:
0008 cost=
9451.955646023
Epoch:
0009 cost=
8655.756353977
Epoch:
0010 cost=
9385.456911932
Epoch:
0011 cost=
8691.026454545
Epoch:
0012 cost=
7808.168955114
Epoch:
0013 cost=
8536.450017614
Epoch:
0014 cost=
8361.853073864
Epoch:
0015 cost=
8577.262535227
Epoch:
0016 cost=
9147.155342045
Epoch:
0017 cost=
8387.879208523
Epoch:
0018 cost=
8323.613027273
Epoch:
0019 cost=
8232.555606250
Epoch:
0020 cost=
8255.203377841
Total cost:
660028.0
Process finished
with exit code
0
123456789101112131415161718192021222324252627282930313233
实现一个去噪自编码器和实现一个单隐含层的神经网络差不多，只不过是在数据输入时做了标准化，并加上了一个高斯噪声，同时我们的输出结果不是数字分类结果，而是复原的数据，因此不需要用标注过的数据进行监督训练。自编码器作为一种无监督学习的方法，它与其它无监督学习的主要不同在于，它不是对数据进行聚类，而是提取其中最有用，最频繁出现的高阶特征，根据这些高阶特征重构数据。
