TensorFlow实现自编码器

TensorFlow实现自编码器 学习笔记

1. 了解概念

自编码器(AutoEncoder)：可以使用自身的高阶特征编码自己。 自编码器其实也是一种神经网络，它的输入和输出是一致的，它借助稀疏编码的思想，目标是使用稀疏的一些高阶特征重新组合来重构自己。

特征的稀疏表达(Sparse Coding): 使用少量的基本特征组合拼装得到更高层抽象的特征。

特点：

  1. 期望输入/输出一致
  2. 希望用高阶特征来重构自己，而不只是复制像素点

2. 作用

自编码器的作用不仅局限于给监督训练做预训练，也可以直接使用自编码器进行特征提取和分析。

3. 对数据进行降维

自编码器的输入节点和输出节点是一致的，但如果只是单纯的复制节点则没有意义。自编码器通常使用少量稀疏的高阶特征来重构输入。所以可以加入以下限制：

  1. 限制中间隐含层节点的数量。如果再给中间隐含层的权重加一个L1的正则，那就可以根据惩罚系数控制隐含节点的稀疏程度。
  2. 给数据加入噪声，即 去躁自编码器(Denoising AutoEncoder)，从噪声中学习出数据的特征。最常使用的是 加性高斯噪声(Additive Gaussian Noise, AGN).

4. TensorFlow 实现自编码器

4.1 导入库。

NumPy、对数据进行预处理的preprocessing模块、MNIST数据的加载模块。

1
2
3
4
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
4.2 定义网络结构

使用 TensorFlow 进行算法设计、训练的核心步骤：

  1. 定义算法公式，也就是神经网络 forward 时的计算；
  2. 定义 loss,选定优化器，并指定优化器优化 loss；
  3. 迭代的对数据进行训练；
  4. 在测试集或验证集上对准确率进行评测；

构建函数：n_input(输入变量数)、n_hidden(隐含节点数)、transfer_function(隐含层激活函数，默认为softplus)、 optimizer(优化器，默认为Adam)、scale(高斯噪声系数，默认为0.1)。

1
2
3
4
5
6
7
8
9
10
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

接下来定义网络结构。

feature = Wx + b
  1. 建立一个能提取特征的隐含层，先将输入 x 加上噪声: x + scale * tf.random_normal((n_input,))。
  2. 使用 transfer 对 (wx+b) 进行激活函数处理。
  3. 经过隐含层后，在输出层进行数据复原、重建操作（即建立 reconstruction层）
  4. 注意：输出层没有使用激活函数
1
2
3
4
5
6
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 = td.add(tf.matmul(self.hidden,
						self.weights['w2']), self.weights['b2'])

定义损失函数和优化器。

这里使用 平方误差(Squared Error) 作为 cost。

1
2
self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
self.optimizer = optimizer.minimize(self.cost)

下一步使用 TensorFlow 的全局参数优化器 tf.global_variables_initializer，创建 session，并直接执行它的 run 方法。

1
2
3
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
4.3 参数初始化

xavier initialization 初始化方法：

概念：Xavier 就是让权重满足0均值，同时方差为 2/(Nin+Nout),分布可以用均匀分布或者高斯分布。

特点：它会根据某一层网络的输入、输出节点数量自动调整最合适的分布。

fan_in 是输入节点的数量， fan_out 是输出节点的数量。

1
2
3
4
5
6
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)

_initialize_weights 初始化函数：

权重w1 需要使用 xavier_init，返回一个适合激活函数的权重初始分布。

1
2
3
4
5
6
7
8
9
10
11
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
4.4 计算损失 cost

partial_fit :就是用一个 batch 数据进行训练并返回当前的损失 cost。

1
2
3
4
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
4.5 模型性能评测

不训练，只求 cost，在测试集上对模型性能进行评测。

1
2
3
def calc_total_cost(self, X):
	return self.sess.run(self.cost, feed_dict = {self.x; X, 
		self.scale: self.training_scale})
4.6 获得隐含层的输出结果

函数目的是提供一个接口来获取抽象后的特征。

自编码器的隐含层的最主要功能是： 学习出数据中的高阶特征。

1
2
3
def transform(self, X):
	return self.sess.run(self.hidden, feed_dict = {self.x; X, 
		self.scale: self.training_scale})
4.7 将高阶特征复原为原始数据

函数将隐含层的输出结果作为输入，通过之后的重建层将提取到的高阶特征复原为原始数据。

1
2
3
4
5
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})
4.8 提取高阶特征并复原数据

输入是 原数据， 输出是 复员后的数据。

1
2
3
def reconstruct(self, X):
	return self.sess.run(self.reconstruction,feed_dict = {self.x; X, 
		self.scale: self.training_scale})
4.9 一些简单的函数

获取隐含层的权重w1

1
2
def getWeights(self):
	return self.sess.run(self.weights['w1'])

获取隐含层的偏置系数b1

1
2
def getBiases(self):
	return self.sess.run(self.weights['b1'])

5. 在 MNIST 数据集上测试

获取数据集并对其进行标准化处理：让数据变成0均值且标准差为1的分布。

方法就是 先减去均值，再除以标准差。

注意：必须保证训练、测试数据都使用完全相同的scaler，这样才能保证后面模型处理数据时的一致性。

1
2
3
4
5
6
7
8
def getDataSet():
	return 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

不放回抽样，获取随机block函数。

1
2
3
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)]

创建实例：

1
2
3
4
5
autoencoder = AdditiveGaussianNoiseAutoencoder(n_input = 784,
				n_hidden = 200,
				transfer_function = tf.nn.softplus,
				optimizer = tf.train.AdamOptimizer(learning_rate = 0.001),
				scale = 0.01)

接下来开始训练。

  1. 随机抽取一个 block 的数据
  2. 计算当前 cost
  3. 求出 avg_cost
  4. 显示当前的迭代数和每一轮的 avg_cost
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n_samples = int(mnist.train.num_examples)
training_epochs = 10
batch_size = 128
display_step = 1
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=:', '{:.9%f}' % format(avg_cost))

最后对训练完的模型进行性能测试。

1
print('Total cost: ' + str(autoencoder.calc_total_cost(X_test)))

6. 运行结果

1
2
3
4
5
6
7
8
9
10
11
Epoch: 0001 cost=: 20285.325176136
Epoch: 0002 cost=: 13014.011207955
Epoch: 0003 cost=: 11046.426732955
Epoch: 0004 cost=: 10171.495172727
Epoch: 0005 cost=: 9557.693106818
Epoch: 0006 cost=: 8829.338232955
Epoch: 0007 cost=: 9524.017826136
Epoch: 0008 cost=: 8726.727809091
Epoch: 0009 cost=: 9077.717231818
Epoch: 0010 cost=: 7851.010675568
Total cost: 730917.0

最终结果 cost 大概为 7000

7. 优化方法

可以通过调整 batch_size、training_epochs、优化器、自编码器的隐含层数、隐含节点数来优化。

8. 结语

自编码器作为一种无监督学习的方法，它与其他无监督学习的主要不同在于，它不是对数据进行聚类，而是提取其中最有用、最频繁出现的高阶特征，根据这些高阶特征重构数据。