无监督的逐层训练，其思想和自编码器非常相似，后者的目标是让神经网络的输出能和原始输入一致，相当于学习一个恒等式y=x。自编码器通常希望使用少量稀疏的高阶特征来重构输入，所以可以加入几种限制。
（1）如果限制中间隐含层节点的数量，比如让中间隐含层节点的数量小于输入／输出节点的数量，就相当于一个降维的过程。此时已经不可能出现复制所有节点的情况，因为中间节点数小于输入节点数，那只能学习数据中最重要的特征复原，将可能不太相关的内容去除。此时，如果再给中间隐含层的权重加一个L1的正则，则可以根据惩罚系数控制隐含节点的稀疏程度，惩罚系数越大，学到的特征组合越稀疏，实际使用（非零权重）的特征数量越少。
（2）如果给数据加入噪声，那么就是Denoising AutoEncoder（去噪自编码器），我们将从噪声中学习出数据的特征。同时，我们也不可能完全复制节点，完全复制并不能去除我们添加的噪声，无法完全复原数据。所以唯有学习数据频繁出现的模式和结构，将无规律的噪声略去，才可以复原数据。
去噪自编码器中最常使用的噪声是加性高斯噪声，当然也可以使用Making Noidse,即随机遮挡的噪声。如果自编码器的隐含层只有一层，那么其原理类似于主成分分析PCA。
Hinton提出了基于深度信念网络（Deep Belief Network，DBN，由多层RBM堆叠而成），每个隐含层都是限制性玻尔兹曼机RBM，一种具有特殊连接分布的神经网络。DBN训练时，需要先对每两层间进行无监督的预训练，这个过程其实就相当于一个多层的自编码器，可以将整个网络的权重初始化到一个理想的分布。最后通过反向传播算法调整模型权重，这个步骤会使用经过标注的信息来做监督性的分类训练。简单地说，Hinton的思路就是先用自编码器的方法进行无监督的预训练，提取特征并初始化权重，然后使用标注信息进行监督式的训练。当然自编码器的作用不仅局限于给监督训练做预训练，直接使用自编码器进行特征提取和分析也是可以的。
下面我们就开始实现最具代表性的去躁自编码器。去躁自编码器的使用范围最广也最通用。而其他几种自编码器，读者可以对代码加以修改自行实现，其中无噪声的自编码器只需要去掉噪声，并保证隐含层结点小于输入层结点；Masking Noise的自编码器只需要将高斯噪声改为随机遮挡噪声；Variational Autoncoder（AVE）则相对复杂，VAE对中间节点的分布有强假设，拥有额外的损失项，且会使用特殊的SGVB（Stochastic Gradient Variational Bayes）算法进行训练。目前VAE还在生成模型中发挥了很大 的作用。
先导入常用库NumPy，还有Scikit-learn中的preprocessing模块，这是一个对数据进行预处理的常用模块。
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as 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.float3下面是一个去噪自编码的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.AdadeltaOptimizer(), 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接下来开始定义网络结构，为x创建一个维度为n_input的占位符，然后建立一个能提取特征的隐含层，先将输入x加上噪声，然后用tf.matmul将加了噪声的输入与隐含层的权重相乘。并使用tf.add加上隐含层的偏置，最后对结果进行激活函数处理。经过隐含层后，需要在输出层进行数据复原，重建操作（即建立reconstruction层）。
self.x = tf.placeholder(tf.float32, [None, self.n_input])
self.x = tf.placeholder(tf.float32, [None, self.n_input])
self.n_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.n_hidden,self.weights['w2']),self.weights['b2'])接下来定义自编码器的损失函数，这里使用平方误差作为损失函数，再定义训练操作作为优化器对损失进行优化，最后创建Session并初始化自编码器的全部模型参数。
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定义计算损失cost及执行一步训练的函数partial_fit。函数里只需让Session执行两个计算图的节点，分别是损失cost和训练过程optimizer，输入的feed_dict包括输入数据x，以及噪声的系数scale。函数partial_fit做的就是用一个batch数据进行训练并返回当前的损失cost。
def partial_fit(self,X):
cost, opt = self.sess.run((self.cost, self.optimiter), feed_dict={self.x: X, self.scale: self.training_scale})
return cost下面为一个只求损失cost的函数，这个函数是在自编码器训练完毕后，在测试集上对模型性能进行评测时会用到的。
def calc_total_cost(self, X):
return self.(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})定义reconstruct函数，它整体运行一遍复原过程，包括提取高阶特征和通过高阶特征复原数据
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'])定义getBiases函数则是获取隐含层的偏置系数b1
def getBiases(self):
return self.sess.run(self.weights['b1'])下面使用定义好的自编码器在MINIST数据集上进行一些简单的性能测试
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)先定义一个对训练、测试数据进行标准化处理的函数，标准化即让数据变成0均值且标准差为1的分布。方法就是先减去均值，再除以标准差。
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_testdef 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)下面定义几个常用参数，总训练样本数，最大训练的轮数(epoch)设为20，batch_size设为128，并设置每隔一轮(epoch)就显示一次损失cost
n_samples=int(mnist.train.num_examples)
training_epochs=20
batch_size=128
display_step=1创建一个自编码器的实例，定义模型输入节点数n_input为784，自编码器的隐含层点数n_hidden为200，隐含层的激活函数transfer_function为softplus，优化器optimizer为Adam且学习速率为0.001，同时将噪声的系数设为0.01
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=748,
n_hidden=200,
transfer_function=tf.nn.softplus,
optimizer=tf.train.AdamOptimizer(learning_rate=0.001),
scale=0.01)下面开始训练过程，在每一轮(epoch)循环开始时，将平均损失avg_cost设为0，并计算总共需要的batch数（通过样本总数除以batch大小），在每一轮迭代后，显示当前的迭代数和这一轮迭代的平均cost。
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)))完整代码如下：
#自编码器
"""
先导入常用库NumPy，还有Scikit-learn中的preprocessing模块，这是一个对数据进行预处理的常用模块。
"""
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
"""
函数说明：实现标准的均匀分布的Xaiver初始化器（Xaiver初始化器做的事情就是让权重被初始化的不大不小，正好合适）
自编码器中会使用一种参数初始化方法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说明：去躁自编码
n_input:输入变量数
n_hidden:隐含层结点数
transfer_function:隐含层激活函数，默认为softplus
optimizer:优化器，默认为Adam
scale：高斯噪声系数，默认为0.1
下面是一个去噪自编码的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
# 接下来开始定义网络结构，为x创建一个维度为n_input的占位符，然后建立一个能提取特征的隐含层，先将输入x加上噪声，然后用tf.matmul将加了噪声的输入与隐含层的权重相乘
# 并使用tf.add加上隐含层的偏置，最后对结果进行激活函数处理。经过隐含层后，需要在输出层进行数据复原，重建操作。
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'])
# 接下来定义自编码器的损失函数，这里使用平方误差作为损失函数，再定义训练操作作为优化器对损失进行优化，最后创建Session并初始化自编码器的全部模型参数。
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
# 定义计算损失cost及执行一步训练的函数partial_fit。函数里只需让Session执行两个计算图的节点，分别是损失cost和训练过程optimizer，输入的feed_dict包括输入数据x，
# 以及噪声的系数scale。函数partial_fit做的就是用一个batch数据进行训练并返回当前的损失cost。
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
# 下面为一个只求损失cost的函数，这个函数是在自编码器训练完毕后，在测试集上对模型性能进行评测时会用到的。
def calc_total_cost(self, X):
return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale})
# 定义transform函数，返回自编码器隐含层的输出结果，它的目的是提供一个接口来获取抽象后的特征，自编码器的隐含层的最主要功能就是学习出数据中的高阶特征。
def transform(self, X):
return self.sess.run(self.hidden, feed_dict={self.x: X, self.scale: self.training_scale})
# 定义generate函数，将隐含层的输出结果作为输入，通过之后的重建层将提取到的高阶特征复原为原始数据
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})
# 定义reconstruct函数，它整体运行一遍复原过程，包括提取高阶特征和通过高阶特征复原数据
def reconstruct(self, X):
return self.sess.run(self.reconstruction, feed_dict={self.x: X, self.scale: self.training_scale})
# 定义getWeights函数的作用是获取隐含层的权重w1
def getWeights(self):
return self.sess.run(self.weights['w1'])
# 定义getBiases函数则是获取隐含层的偏置系数b1
def getBiases(self):
return self.sess.run(self.weights['b1'])
# 下面使用定义好的自编码器在MINIST数据集上进行一些简单的性能测试
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
# 先定义一个对训练、测试数据进行标准化处理的函数，标准化即让数据变成0均值且标准差为1的分布。方法就是先减去均值，再除以标准差。
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
# 再定义一个获取随机block数据的函数：取一个从0到len(data)-batch_size之间的随机整数，再以这个随机数作为block的起始位置，然后顺序取到一个batch size的数据。
# 需要注意的是，这属于不放回抽样，可以提高数据的利用效率
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)]
# 使用之前定义的standard_scale函数对训练集、测试机进行标准化变换
X_train,X_test = standard_scale(mnist.train.images,mnist.test.images)
# 下面定义几个常用参数，总训练样本数，最大训练的轮数(epoch)设为20，batch_size设为128，并设置每隔一轮(epoch)就显示一次损失cost
n_samples=int(mnist.train.num_examples)
training_epochs=20
batch_size=128
display_step=1
# 创建一个自编码器的实例，定义模型输入节点数n_input为784，自编码器的隐含层点数n_hidden为200，隐含层的激活函数transfer_function为softplus，优化器optimizer为Adam
# 且学习速率为0.001，同时将噪声的系数设为0.01
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784,
n_hidden=200,
transfer_function=tf.nn.softplus,
optimizer=tf.train.AdamOptimizer(learning_rate=0.001),
scale=0.01)
#下面开始训练过程，在每一轮(epoch)循环开始时，将平均损失avg_cost设为0，并计算总共需要的batch数（通过样本总数除以batch大小），在每一轮迭代后，显示当前的迭代数和这一轮迭代的平均cost。
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)))结果如下：
Epoch: 0001 cost= 18873.635785227
Epoch: 0002 cost= 13810.682803409
Epoch: 0003 cost= 11296.059379545
Epoch: 0004 cost= 9953.583925568
Epoch: 0005 cost= 9876.701135227
Epoch: 0006 cost= 9600.371899432
Epoch: 0007 cost= 9481.933126136
Epoch: 0008 cost= 9133.851065341
Epoch: 0009 cost= 8465.892460227
Epoch: 0010 cost= 8837.208538636
Epoch: 0011 cost= 8159.771985795
Epoch: 0012 cost= 8535.869119318
Epoch: 0013 cost= 8590.008203977
Epoch: 0014 cost= 8070.600359091
Epoch: 0015 cost= 7898.707325568
Epoch: 0016 cost= 8890.883271591
Epoch: 0017 cost= 7789.370526136
Epoch: 0018 cost= 7417.424665909
Epoch: 0019 cost= 7735.282494886
Epoch: 0020 cost= 7589.120931818
Total cost:650085.0
可以发现，实现自编码器和实现一个单隐藏层的神经网络差不多，只不过是在数据输入时做了标准化，并加上类一个高斯噪声，同时我们的输出结果不是数字分类结果，而是复原的数据，因此不需要用标注过的数据进行监督训练。自编码器作为一种无监督的学习方法，它与其他无监督学习的主要不同在于，它不是对数据进行聚类，而是提取其中最有用、最频繁出现的高阶特征，根据这些特征重构数据。