TensorFlow实现自编码器

概述

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

image.png

自动编码器(autoencoder) 是神经网络的一种，该网络可以看作由两部分组成：一个编码器函数h = f(x) 和一个生成重构的解码器r = g(h)。传统上，自动编码器被用于降维或特征学习。

参数初始化-Xavier

如果深度学习模型的权重初始化得太小，那么信号将在每层间传递时逐渐缩小而难以产生作用。
如果权重初始化得太大，那信号将在每层间传递时逐渐放大并导致发散和失效。

实现

import tensorflow as tf

import numpy as np

import sklearn.preprocessing as prep

from tensorflow.examples.tutorials.mnist import input_data

# fan_in输入节点数量 fan_out输出节点数量

# 让权重被初始化得不大不小，正好合适

# mean = 0; variance = 2/(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 AdditiveGaussianNoiseAutoencoder(object):

# 输入变量数 隐层节点数 激活函数 优化器 scale高斯噪声系数

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

# 参数初始化, 初始化函数_initialize_weights

networks_weights = self._initialize_weights()

self.weights = networks_weights

# --- 开始定义网络结构 ---

self.x = tf.placeholder(tf.float32, [None, self.n_input])

# 建立提取特征的隐含层

# 1 先将输入x加入噪声，再将加了噪声的输入与隐含层的权重w1相乘，并加上隐含层的偏置b1

# 2 对结果进行激活函数处理

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)

# 创建Session

init = tf.global_variables_initializer()

self.sess = tf.Session()

self.sess.run(init)

# --- 定义初始化函数_initialize_weights ---

def _initialize_weights(self):

# 创建字典

all_weights = dict()

# w1初始化

all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden))

# 其它初始化为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

# 定义一个batch数据进行训练并返回当前cost

def partial_fit(self, X):

# feed_dict为输入数据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})

# 返回自编码器隐含层的输出结果:提取的特征

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.resctruction,

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'])

# 载入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数据的函数：不放回抽样

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

# 创建一个AGN自编码器

autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784,

n_hidden=200,

transfer_function=tf.nn.softplus,

optimizer=tf.train.AdagradOptimizer(learning_rate=0.001),

scale=0.01)

# 开始训练

for epoch in range(training_epochs):

# 平均损失函数

avg_cost = 0.

# 总共的batch数

total_batch = int(n_samples / batch_size)

for i in range(total_batch):

# 使用get_random_block_from_data获取随机batch数据

batch_xs = get_random_block_from_data(X_train, batch_size)

# 使用partial_fit进行训练，并返回cost

cost = autoencoder.partial_fit(batch_xs)

# 将当前的cost整合到avg_cost中

avg_cost += cost / n_samples * batch_size

# 每一轮迭代后，显示当前的迭代数和这一轮迭代的平均cost

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)))

结果

image.png