一.概述
早年学者研究稀疏编码（sparse coding）时,他们收集了大量的黑白风景照，并且从中提取了许多16*16的图像碎片,他们发现几乎所有的图片碎片都可以由64种正交的组合得到，并且组合出一张图片需要的边的数量是很少的，即是稀疏的。
自编码器，顾名思义，既可以用自己的高维特征编码自己。自编码也是一种神经网络，他的输入和输出是一致的，他借助稀疏编码的思想，目标是使用稀疏的的一些高维特征重新组合来重构自己。
因此他有两个显著特征：
- 期望输入输出一致。
- 希望使用高阶特征来重构自己，而不是简单的像素复制。
自编码器通常希望使用少量的稀疏特征，来重构输入，所以，我们可以加入几个限制。
- 限制隐含层节点的数目，输入节点大于隐含层节点的数目，相当于一个降维的过程。
- 在数据中加入噪声，我们将从噪声中学习数据特征。
Hinton教授提出了提出了基于深度信念网络（deep belife network ,DBN),其思路就是先使用自编码器的方式进行无监督的预训练，提取特征并初始化权重。然后使用标注信息进行无监督的训练。主要解决了网络过深带来的梯度弥散。
二 Tensorflow实现去噪自编码器
1 导入库
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data#下载minist数据集2 预处理函数
1.初始化参数函数。
通过tf.random_uniform()创建了一个范围在(low,high)的均匀分布。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)2.对测试数据进行标准化
所谓标准化，就是让数据变为均值为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_test3.随机获取block数据的函数。
取一个从0到len(data)-batch_size之间的随机整数，以这个数据作为起始点取到一个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)]3 定义去噪自编码网络结构
去噪自编码的class包含一个构建函数init()，和其他的成员函数。
1.初始化网络参数模型
**初始化网络参数。**_init_构建函数包含的输入有：n_input(输入变量数)，n_hidden(隐含层节点数)，transfer_function(隐含层激活函数，默认为softplus)，optimizer（优化器，默认为adam），scale(高斯系数，0.1)
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网络模型结构。
1. 输入x上加上噪声self.x + scale * tf.random_normal((n_input,)，再相乘w，相加b，最后通过激活层输出。
2. 在输出层数据复原。
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'])损失函数。
3. 用平方误差作为损失函数。用subtract求差，用pow求平方，用reduce_sum求和。
4. 用optimizer优化cost.
5. 创建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)2.初始化权值（w,b）。
创建一个字典all_weights用于保存参数。用xavier_init函数初始化参数，输出层没有激活函数，故w，b都为0.
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_weights3.训练一个batch的数据，并且,返回当前的损失cost。
- session执行两个计算图的节点，分别是损失cost,optimizer。
- feed_dict包括输入数据x，以及噪声scale。
def partial_fit(self, X):#训练一个批次的数据
cost, opt = self.sess.run((self.cost, self.optimizer), feed_dict = {self.x: X,
self.scale: self.training_scale
})4.测试模型时，计算损失函数cost.
该损失函数不需要训练优化。其余同上。
def calc_total_cost(self, X):
return self.sess.run(self.cost, feed_dict = {self.x: X,
self.scale: self.training_scale
})5.返回自编码器隐含层的输出结果。
自编码器的隐含层最主要的功能就是学习出数据中的高阶特征。这个函数提供了一个接口来获取抽象后的特征。
def transform(self, X):
return self.sess.run(self.hidden, feed_dict = {self.x: X,
self.scale: self.training_scale
})6.将高阶特征复原原始数据。
该函数将隐含层的输出结果作为输入，通过重建层将提取到的高阶特征复原为原始数据。
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})7.整体运行一遍复原过程。
即包括transform和generate模块。输入数据是原始数据，输出数据是复原数据。
def reconstruct(self, X):
return self.sess.run(self.reconstruction, feed_dict = {self.x: X,
self.scale: self.training_scale
})8.获取隐含层参数
def getWeights(self):
return self.sess.run(self.weights['w1'])
def getBiases(self):
return self.sess.run(self.weights['b1'])4 主函数
1.标准化训练集测试集。
mnist = input_data.read_data_sets('MNIST_data', one_hot = True)2.定义参数
n_samples = int(mnist.train.num_examples)#总训练样本数
training_epochs = 20#最大训练轮数
batch_size = 128#批次大小
display_step = 1#每轮显示一次损失函数3.定义AGN自编码实例
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input = 784,#输入大小
n_hidden = 200,#隐含层节点大小
transfer_function = tf.nn.softplus,#激活函数
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001),#优化器
scale = 0.01)#噪声系数4.开始训练
1. 计算批次数目
2. 用get_random_block_from_data随机抽取一个block
3. 用partial_fit训练本批次，计算cost
4. 求cost的平均
for epoch in range(training_epochs):
avg_cost = 0.
total_batch = int(n_samples / batch_size)
# Loop over all batches
for i in range(total_batch):
batch_xs = get_random_block_from_data(X_train, batch_size)
# Fit training using batch data
cost = autoencoder.partial_fit(batch_xs)
# Compute average loss
avg_cost += cost / n_samples * batch_size
# Display logs per epoch step
if epoch % display_step == 0:
print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost))
5.测试
print("Total cost: " + str(autoencoder.calc_total_cost(X_test)))三 总结
自编码器与多层感知器不同点在于
- 数据输入时加了标准化，并且加了高斯噪声。
- 输出结果不是分类数据，而是复原数据。
- 无监督学习
自编码器与聚类不同在于，自编码提取的是最有用，最频繁出现的高阶特征。一般用于网络结构的预训练。