深度学习算法(第27期)----栈式自编码器

智能算法

发布于 2019-09-29 15:13:36

1.7K0

发布于 2019-09-29 15:13:36

文章被收录于专栏：智能算法

深度学习算法(第26期)----深度网络中的自编码器今天我们更进一步一起学一下栈式自编码器。

栈式自编码器

跟之前我们学过的其他神经网络一样，自编码器也可以有多个隐藏层。这种有多个隐藏层的自编码器被称为栈式自编码器（类似内存中的堆栈），也称为深度自编码器。增加更多的层，有助于自编码器学到更为复杂的编码，然而，需要注意的是不能够让自编码器太过强大，假设一个自编码器太过强大，而学到了将每一个输入映射为一个任意值，而解码的时候反向映射。显然，这样的自编码器能够很完美的重构训练数据，但是并没有学到任何有效的表现数据的方法，泛化能力必然一塌糊涂。

栈式自编码器一般是一个关于中心隐藏层（编码层）对称的结构，或者说像一个三明治。例如对于我们很熟悉的MNIST数据集的一个自编码器应该是什么样子的呢？如下图：

在这个例子中，有784个输入，接着是一个300个神经元的隐藏层，然后中心隐藏层（编码层）是由150个神经元组成，再接着就又是300个神经元，最终输出为784个神经元（跟输入一致）。

tensorflow 实现

我们可以用常规的深度MLP来实现一个栈式自编码器，如之前所学的一样：深度学习三人行(第3期)----TensorFlow从DNN入手如下代码创建了一个MNIST的栈式自编码器，其中用He初始化，ELU激活函数等。

n_inputs = 28 * 28 # for MNIST
n_hidden1 = 300
n_hidden2 = 150 # codings
n_hidden3 = n_hidden1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.001

X = tf.placeholder(tf.float32, shape=[None, n_inputs])
with tf.contrib.framework.arg_scope(
        [fully_connected],
        activation_fn=tf.nn.elu,
        weights_initializer=tf.contrib.layers.variance_scaling_initializer(),
        weights_regularizer=tf.contrib.layers.l2_regularizer(l2_reg)):
    hidden1 = fully_connected(X, n_hidden1)
    hidden2 = fully_connected(hidden1, n_hidden2) # codings
    hidden3 = fully_connected(hidden2, n_hidden3)
    outputs = fully_connected(hidden3, n_outputs, activation_fn=None)

reconstruction_loss = tf.reduce_mean(tf.square(outputs - X)) # MSE

reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
loss = tf.add_n([reconstruction_loss] + reg_losses)

optimizer = tf.train.AdamOptimizer(learning_rate)
training_op = optimizer.minimize(loss)

init = tf.global_variables_initializer()

我们可以按照一般流程训练模型，注意这里并没有用到标签。

n_epochs = 5
batch_size = 150

with tf.Session() as sess:
    init.run()
    for epoch in range(n_epochs):
        n_batches = mnist.train.num_examples // batch_size
        for iteration in range(n_batches):
            X_batch, y_batch = mnist.train.next_batch(batch_size)
            sess.run(training_op, feed_dict={X: X_batch})

权重关联

像我们刚才创建的一样，当一个自编码器是完全对称的时候，为了加速训练和放置过拟合，一个通常的做法就是将编码器的权重和解码器的权重捆绑在一起共用，这样权重的数量就能减半。其实在tensorflow中，用fully_connected()函数实现这个权重捆绑还是有一些麻烦的，一般手动定义这些层还是比较简单的，虽然下面代码看起来有些冗余：

activation = tf.nn.elu
regularizer = tf.contrib.layers.l2_regularizer(l2_reg)
initializer = tf.contrib.layers.variance_scaling_initializer()

X = tf.placeholder(tf.float32, shape=[None, n_inputs])

weights1_init = initializer([n_inputs, n_hidden1])
weights2_init = initializer([n_hidden1, n_hidden2])

weights1 = tf.Variable(weights1_init, dtype=tf.float32, name="weights1")
weights2 = tf.Variable(weights2_init, dtype=tf.float32, name="weights2")
weights3 = tf.transpose(weights2, name="weights3") # tied weights
weights4 = tf.transpose(weights1, name="weights4") # tied weights

biases1 = tf.Variable(tf.zeros(n_hidden1), name="biases1")
biases2 = tf.Variable(tf.zeros(n_hidden2), name="biases2")
biases3 = tf.Variable(tf.zeros(n_hidden3), name="biases3")
biases4 = tf.Variable(tf.zeros(n_outputs), name="biases4")

hidden1 = activation(tf.matmul(X, weights1) + biases1)
hidden2 = activation(tf.matmul(hidden1, weights2) + biases2)
hidden3 = activation(tf.matmul(hidden2, weights3) + biases3)
outputs = tf.matmul(hidden3, weights4) + biases4

reconstruction_loss = tf.reduce_mean(tf.square(outputs - X))
reg_loss = regularizer(weights1) + regularizer(weights2)
loss = reconstruction_loss + reg_loss

optimizer = tf.train.AdamOptimizer(learning_rate)
training_op = optimizer.minimize(loss)

init = tf.global_variables_initializer()

这段代码是比较直接的实现了权重捆绑，但是有几点还是需要注意的：