深度学习之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:", '%04d' % (epoch + 1), "cost=","{:.9f}".format(avg_cost))
print("Total cost:" + str(autoencoder.calc_total_cost(X_test)))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
结果:
/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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
实现一个去噪自编码器和实现一个单隐含层的神经网络差不多,只不过是在数据输入时做了标准化,并加上了一个高斯噪声,同时我们的输出结果不是数字分类结果,而是复原的数据,因此不需要用标注过的数据进行监督训练。自编码器作为一种无监督学习的方法,它与其它无监督学习的主要不同在于,它不是对数据进行聚类,而是提取其中最有用,最频繁出现的高阶特征,根据这些高阶特征重构数据。