TensorFlow学习－－自编码器/稀疏自编码器/堆叠自编码器

自编码器(Auto Encoder)

神经网络常常用于分类，通过定义一个目标函数衡量输出与目标值之间的差异，然后通过调整系统的参数使系统尽量拟合训练数据．

而对每一层神经网络来说，前一层的输出都是可看做未加工的初始数据，而这一层则是对初始数据进行加工组织的更高阶的特征．

设由无类别标签的训练样本集合 ｛x(1)　x(2)　x(3)　...｝,x(i)∈Rn

自编码神经网络是一种无监督学习算法，使用反向传播算法，并让目标值等于输出值．

自编码神经网络结构如图：

（输入数据为 x, 隐藏层为 h）



实际上，当训练结束后，输出层已经没有意义了．网络可以学习出一种特征变换h，即原始输入数据的另一种表示．

此时，根据隐藏层维度和输入数据维度的大小可以分为以下两种情况：

隐藏层维度小于输入数据维度

即从 x→h的变换是一种降维操作，网络试图用更小的维度去表示原始数据且尽量不损失数据信息．

隐藏层维度大于输入数据维度

当隐藏层神经元数量较多时，通过给神经元加入稀疏性限制(使h的表达尽量稀疏，即有大量的维度为0未被激活)来发现输入数据中的结构．此时，编码器为稀疏编码器．

堆叠自编码器（ASE）

单个自编码器通过虚构 x→h→x的三层网络能够学习出一种特征变换 h=f(x).

自编码器模型如图：



可以将 h再当作原始数据信息训练一个新的自编码器，得到新的特征表达．即堆叠自编码器(Stacked Auto-Encoder)或栈式自编码器．



整个网络的训练是逐层进行的即逐层非监督预训练(layer-wise unsuperwised pre-training).

TensorFlow实现自编码器

下载MNIST数据集：lecun主页

将数据下载到文件夹Mnist_data下：



代码及注释：

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

# Xaiver初始化器保证权重初始化的不大不小均值为0方差为(2/(输入节点总数+输出节点总数))的均匀分布或高斯分布
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
class AdditiveGaussianNoiseAutoencoder(object):
# 隐含层激活函数默认为softplus
# 优化器,默认为Adam
def __init__(self, n_input, n_hidden, transer_function=tf.nn.softplus,
optimizer=tf.train.AdamOptimizer(), scale=0.1):
# 输入变量数
self.n_input = n_input
# 隐含节点数
self.n_hidden = n_hidden
self.transfer = transer_function
self.scale = tf.placeholder(tf.float32)
self.traning_scale = scale
# 参数初始化
network_weights = self.__initialize_weights__()
self.weights = network_weights

# 定义网络结构
# 为输入x创建一个维度为n_input的占位符
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()
# w1使用xavier_init函数初始化：
# 传入输入节点数和隐含层节点数,返回一个比较适合于softplus等激活函数的权重初始分布
all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden))
# b1 w2 b2全部置0
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):
# 用一个batch数据进行训练并返回当前的损失
cost, opt = self.sess.run((self.cost, self.optimizer),
feed_dict={self.x: X, self.scale: self.traning_scale})
return cost

# 只求损失cost,在测试集上对模型性能进行评测
def calc_total_cost(self, X):
return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.traning_scale})

# 返回自编码器隐含层的输出结果
def transform(self, X):
# 提供一个接口获取抽象后的特征,隐含层的主要功能即学习出数据中的高阶特性
return self.sess.run(self.hidden, feed_dict={self.x: X, self.scale: self.traning_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})

# 包括transform和generate两部分,输入原数据输出也是原数据
def reconstruct(self, X):
return self.sess.run(self.reconstruction, feed_dict={self.x: X, self.scale: self.training_scale})

# 获取隐含层的权重w1
def getWeights(self):
return self.sess.run(self.weights['w1'])

# 获取隐含层的偏执系数b1
def getBiases(self):
return self.sess.run(self.weights['b1'])

# 标准化处理函数：将数据变为均值为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

# 随机抽样batch_size个数据
def get_random_block_from_data(data, batch_size):
# 随机选择一个0到len(data) - batch_size之间的随机整数
start_index = np.random.randint(0, len(data) - batch_size)
# 顺序选择一个batch_size大小的数据
return data[start_index:(start_index + batch_size)]

# 读取Mnist_data文件夹下的MNIST数据集
mnist = input_data.read_data_sets('Mnist_data', one_hot=True)

# 对训练集测试集进行标准化变换
X_train, X_test = standard_scale(mnist.train.images, mnist.test.images)
# 总训练样本数
n_samples = int(mnist.train.num_examples)
# 最大轮数
training_epochs = 30
batch_size = 128
# 每隔1轮显示一次损失
display_step = 1
# 优化器optimizer为Adam且学习速率为0.001,噪声系数设为0.01
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784,
n_hidden=200, transer_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_size个数据
batch_xs = get_random_block_from_data(X_train, batch_size)
# 计算当前的损失
cost = autoencoder.partial_fit(batch_xs)
# 将当前损失整合到avg_cost
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))

输出：

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

Epoch: 0001 cost= 18393.803394318
Epoch: 0002 cost= 12056.212395455
Epoch: 0003 cost= 11560.195284091
Epoch: 0004 cost= 9874.588271023
Epoch: 0005 cost= 9680.366493750
Epoch: 0006 cost= 8302.406408523
Epoch: 0007 cost= 9170.771014205
Epoch: 0008 cost= 9230.874527273
Epoch: 0009 cost= 8316.486203977
Epoch: 0010 cost= 9159.939965909
Epoch: 0011 cost= 8616.586401136
Epoch: 0012 cost= 8459.991118182
Epoch: 0013 cost= 7664.576960227
Epoch: 0014 cost= 8489.886681250
Epoch: 0015 cost= 7643.553435795
Epoch: 0016 cost= 8587.016578409
Epoch: 0017 cost= 7797.239460795
Epoch: 0018 cost= 7596.627213068
Epoch: 0019 cost= 7543.282728409
Epoch: 0020 cost= 7634.373622159
Epoch: 0021 cost= 8546.334438636
Epoch: 0022 cost= 7568.472099432
Epoch: 0023 cost= 8288.032989773
Epoch: 0024 cost= 7934.257227273
Epoch: 0025 cost= 7766.447797727
Epoch: 0026 cost= 7191.460046591
Epoch: 0027 cost= 7610.152782386
Epoch: 0028 cost= 7378.358159091
Epoch: 0029 cost= 7491.907940909
Epoch: 0030 cost= 8503.457048864
Total cost:637764.0

参考：自编码算法与稀疏性

为什么稀疏自编码器很少见到多层的

＜TensorFlow实战＞