文档章节

Stacked Autoencoder

AllenOR灵感
 AllenOR灵感
发布于 2017/09/10 01:25
字数 1548
阅读 15
收藏 0


深度学习的威力在于其能够逐层地学习原始数据的多种表达方式。每一层都以前一层的表达特征为基础,抽取出更加抽象,更加适合复杂的特征,然后做一些分类等任务。

堆叠自编码器(Stacked Autoencoder,SAE)实际上就是做这样的事情,如前面的自编码器稀疏自编码器降噪自编码器都是单个自编码器,它们通过虚构一个 x -> h -> x 的三层网络,能过学习出一种特征变化 h = f(wx+b) 。实际上,当训练结束后,输出层已经没有什么意义了,我们一般将其去掉,即将自编码器表示为:


之前之所以将自编码器模型表示为3层的神经网络,那是因为训练的需要,我们将原始数据作为假想的目标输出,以此构建监督误差来训练整个网络。等训练结束后,输出层就可以去掉了,因为我们只关心的是从 xh 的变换。

接下来的思路就很自然了,我们已经得到特征表达 h ,那么我们可不可以将 h 再作为原始信息,训练一个新的自编码器,得到新的特征表达呢?当软可以,而且这就是所谓的堆叠自编码器(Stacked Autoencoder,SAE)。Stacked 就是逐层堆叠的意思,这个跟“栈”有点像。当把多个自编码器 Stack 起来之后,这个系统看起来就像这样:


这样就把自编码器改成了深度结构了,即 learning multiple levels of representation and abstraction (Hinton, Bengio, LeCun, 2015)。需要注意的是,整个网络的训练不是一蹴而就的,而是逐层进行的。比如说我们要训练一个 n -> m -> k 结构的网络,实际上我们是先训练网络 n -> m -> n ,得到 n -> m 的变换,然后再训练 m -> k -> m 网络,得到 m -> k 的变换。最终堆叠成 SAE ,即为 n -> m -> k 的结果,整个过程就像一层层往上面盖房子,这就是大名鼎鼎的 layer-wise unsuperwised pre-training (逐层非监督预训练)。

接下来我们来看一个具体的例子,假设你想要训练一个包含两个隐藏层的堆叠自编码器,用来训练 MNIST 手写数字分类。

首先,你需要用原始输入 x(k) 训练第一个稀疏自编码器中,它能够学习得到原始输入的一阶特征表示 h(1)(k),如下图所示:


接着,你需要把原始数据输入到上述训练好的稀疏自编码器中,对于每一个输入 x(k) ,都可以得到它对应的一阶特征表示 h(1)(k) 。然后你再用这些一阶特征作为另一个稀疏自编码器的输入,使用它们来学习二阶特征 h(2)(k) ,如下图:


同样,再把一阶特征输入到刚训练好的第二层稀疏自编码器中,得到每个 h(1)(k) 对应的二阶特征激活值 h(2)(k) 。接下来,你可以把这些二阶特征作为 softmax 分类器的输入,训练得到一个能将二阶特征映射到数字标签的模型。如下图:


最终,你可以将这三层结合起来构建一个包含两个隐藏层和一个最终 softmax 分类器层的堆叠自编码网络,这个网络能够如你所愿地对 MNIST 数据集进行分类。最终模型如下图:


实验代码如下:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np
import input_data


N_INPUT = 28*28
N_HIDDEN_1 = 1000
N_OUTPUT_1 = N_INPUT
N_HIDDEN_2 = 1500
N_OUTPUT_2 = N_HIDDEN_1
N_OUTPUT = 10
BATCH_SIZE = 16 0
EPOCHES = 10
RHO = .1
BETA = tf.constant(3.0)
LAMBDA = tf.constant(.0001)

w_model_one_init = np.sqrt(6. / (N_INPUT + N_HIDDEN_1))

model_one_weights = {
    "hidden": tf.Variable(tf.random_uniform([N_INPUT, N_HIDDEN_1], minval = -w_model_one_init, maxval = w_model_one_init)),
    "out": tf.Variable(tf.random_uniform([N_HIDDEN_1, N_OUTPUT_1], minval = -w_model_one_init, maxval = w_model_one_init))
}
model_one_bias = {
    "hidden": tf.Variable(tf.random_uniform([N_HIDDEN_1], minval = -w_model_one_init, maxval = w_model_one_init)),
    "out": tf.Variable(tf.random_uniform([N_OUTPUT_1], minval = -w_model_one_init, maxval = w_model_one_init))
}

w_model_two_init = np.sqrt(6. / (N_HIDDEN_1 + N_HIDDEN_2))

model_two_weights = {
    "hidden": tf.Variable(tf.random_uniform([N_HIDDEN_1, N_HIDDEN_2], minval = -w_model_two_init, maxval = w_model_two_init)),
    "out": tf.Variable(tf.random_uniform([N_HIDDEN_2, N_OUTPUT_2], minval = -w_model_two_init, maxval = w_model_two_init))
}
model_two_bias = {
    "hidden": tf.Variable(tf.random_uniform([N_HIDDEN_2], minval = -w_model_two_init, maxval = w_model_two_init)),
    "out": tf.Variable(tf.random_uniform([N_OUTPUT_2], minval = -w_model_two_init, maxval = w_model_two_init))
}

w_model_init = np.sqrt(6. / (N_HIDDEN_2 + N_OUTPUT))

model_weights = {
    "out": tf.Variable(tf.random_uniform([N_HIDDEN_2, N_OUTPUT], minval = -w_model_init, maxval = w_model_init))
}
model_bias = {
    "out": tf.Variable(tf.random_uniform([N_OUTPUT], minval = -w_model_init, maxval = w_model_init))
}


model_one_X = tf.placeholder("float", [None, N_INPUT])
model_two_X = tf.placeholder("float", [None, N_HIDDEN_1])
Y = tf.placeholder("float", [None, N_OUTPUT])

def model_one(X):
    hidden = tf.sigmoid(tf.add(tf.matmul(X, model_one_weights["hidden"]), model_one_bias["hidden"]))
    out = tf.sigmoid(tf.add(tf.matmul(hidden, model_one_weights["out"]), model_one_bias["out"]))
    return [hidden, out]

def model_two(X):
    hidden = tf.sigmoid(tf.add(tf.matmul(X, model_two_weights["hidden"]), model_two_bias["hidden"]))
    out = tf.sigmoid(tf.add(tf.matmul(hidden, model_two_weights["out"]), model_two_bias["out"]))
    return [hidden, out]

def model(X):
    hidden_1 = tf.sigmoid(tf.add(tf.matmul(X, model_one_weights["hidden"]), model_one_bias["hidden"]))
    hidden_2 = tf.sigmoid(tf.add(tf.matmul(hidden_1, model_two_weights["hidden"]), model_two_bias["hidden"]))
    out = tf.add(tf.matmul(hidden_2, model_weights["out"]), model_bias["out"])
    return out

def KLD(p, q):
    invrho = tf.sub(tf.constant(1.), p)
    invrhohat = tf.sub(tf.constant(1.), q)
    addrho = tf.add(tf.mul(p, tf.log(tf.div(p, q))), tf.mul(invrho, tf.log(tf.div(invrho, invrhohat))))
    return tf.reduce_sum(addrho)

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

# model one
model_one_hidden, model_one_out = model_one(model_one_X)
# loss
model_one_cost_J = tf.reduce_sum(tf.pow(tf.sub(model_one_out, model_one_X), 2))
# cost sparse
model_one_rho_hat = tf.div(tf.reduce_sum(model_one_hidden), N_HIDDEN_1)
model_one_cost_sparse = tf.mul(BETA, KLD(RHO, model_one_rho_hat))
# cost reg
model_one_cost_reg = tf.mul(LAMBDA, tf.add(tf.nn.l2_loss(model_one_weights["hidden"]), tf.nn.l2_loss(model_one_weights["out"])))
# cost function
model_one_cost = tf.add(tf.add(model_one_cost_J, model_one_cost_reg), model_one_cost_sparse)
train_op_1 = tf.train.AdamOptimizer().minimize(model_one_cost)
# =======================================================================================

# model two
model_two_hidden, model_two_out = model_two(model_two_X)
# loss
model_two_cost_J = tf.reduce_sum(tf.pow(tf.sub(model_two_out, model_two_X), 2))
# cost sparse
model_two_rho_hat = tf.div(tf.reduce_sum(model_two_hidden), N_HIDDEN_2)
model_two_cost_sparse = tf.mul(BETA, KLD(RHO, model_two_rho_hat))
# cost reg
model_two_cost_reg = tf.mul(LAMBDA, tf.add(tf.nn.l2_loss(model_two_weights["hidden"]), tf.nn.l2_loss(model_two_weights["out"])))
# cost function
model_two_cost = tf.add(tf.add(model_two_cost_J, model_two_cost_reg), model_two_cost_sparse)
train_op_2 = tf.train.AdamOptimizer().minimize(model_two_cost)
# =======================================================================================

# final model
model_out = model(model_one_X)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(model_out, Y))
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
predict_op = tf.argmax(model_out, 1)
# =======================================================================================


with tf.Session() as sess:

    init = tf.initialize_all_variables()
    sess.run(init)

    for i in xrange(EPOCHES):
        for start, end in zip(range(0, len(trX), BATCH_SIZE), range(BATCH_SIZE, len(trX), BATCH_SIZE)):
            input_ = trX[start:end]
            sess.run(train_op_1, feed_dict = {model_one_X: input_})
    print 'finish model one ...'

    for i in xrange(EPOCHES):
        for start, end in zip(range(0, len(trX), BATCH_SIZE), range(BATCH_SIZE, len(trX), BATCH_SIZE)):
            input_ = trX[start:end]
            input_ = sess.run(tf.sigmoid(tf.add(tf.matmul(input_, model_one_weights["hidden"]), model_one_bias["hidden"])))
            sess.run(train_op_2, feed_dict = {model_two_X: input_})
    print 'finish model two ...'

    for i in xrange(EPOCHES):
        for start, end in zip(range(0, len(trX), BATCH_SIZE), range(BATCH_SIZE, len(trX), BATCH_SIZE)):
            input_ = trX[start:end]
            sess.run(train_op, feed_dict = {model_one_X: input_, Y: trY[start:end]})

        print i, np.mean(np.argmax(teY, axis = 1) == sess.run(predict_op, feed_dict = {model_one_X: teX, Y: teY}))

    print 'finish model ...'
    print np.mean(np.argmax(teY, axis = 1) == sess.run(predict_op, feed_dict = {model_one_X: teX, Y: teY}))

Reference:

UFLDL

知乎

本文转载自:http://www.jianshu.com/p/51d5639c2c71

共有 人打赏支持
AllenOR灵感
粉丝 10
博文 2634
码字总数 82983
作品 0
程序员
基于 Tensorflow 的栈式自编码器--TFSAE

TFSAE 是基于 Tensorflow 的 Stacked AutoEncoder (栈式自编码器)。可用于数据降维、特征融合。下图是 TFSAE 将 iris 数据集中的 4 维特征融合为 2 维特征的示例: Encoded Iris Data(2 feat...

CrawlScript
2017/08/29
102
0
AI学习笔记——Autoencoders(自编码器)

Autoencoder 的基本概念 之前的文章介绍过机器学习中的监督学习和非监督学习,其中非监督学习简单来说就是学习人类没有标记过的数据。对于没有标记的数据最常见的应用就是通过聚类(Clusteri...

Hongtao洪滔
07/13
0
0
TensorFlow人工智能入门教程之十四 自动编码机AutoEncoder 网络

好久没有更新了,最近 想在空余时间 之外 ,对以前创业人工智能平台进行封装,想做一个人工智能顶层框架,我是实战派,不是理论派,什么BP FF 什么 SGD 等等 一大堆优化 optimation 知道偏微...

zhuyuping
2016/06/05
2.8K
1
DDos攻击,使用深度学习中 栈式自编码的算法

转自:http://www.airghc.top/2016/11/10/Dection-DDos/ 最近研究了一篇论文,关于检测DDos攻击,使用了深度学习中 栈式自编码的算法,现在简要介绍一下内容 论文下载 讨论班讲解pdf-by airg...

桃子红了呐
2017/11/09
0
0
机器学习笔记-Deep Learning

林轩田机器学习技法关于特征学习系列,其中涉及到 , , , , , , - , 等。 机器学习笔记-Neural Network 机器学习笔记-Deep Learning 机器学习笔记-Radial Basis Function Network 机器...

robin_Xu_shuai
2017/12/18
0
0

没有更多内容

加载失败,请刷新页面

加载更多

腾讯三大运维开源项目齐聚“OSCAR开源先锋日”

10月20日,腾讯开源三大运维开源项目——TARS、蓝鲸和织云Metis首次集结,参与了由中国信息通信研究院主办、云计算标准与开源推进委员会承办的 “OSCAR开源先锋日”。会上,腾讯开源团队与前...

腾讯开源
8分钟前
0
0
JAVA并发-从缓存一致性说volatile 讲的很好

学过计算机组成原理的一定知道,为了解决内存速度跟不上CPU速度这个问题,在CPU的设计中加入了缓存机制,缓存的速度介于CPU和主存之间。在进行运算的时候,CPU将需要的数据映射一份在缓存中,...

码代码的小司机
26分钟前
0
0
IDEA 调试功能

1.设置断点 选定要设置断点的代码行,在行号的区域后面单击鼠标左键即可。 2.开启调试会话 点击红色箭头指向的小虫子,开始进入调试。 IDE下方出现Debug视图,红色的箭头指向的是现在调试程序...

狼王黄师傅
34分钟前
0
0
Java面试170题

1、面向对象的特征有哪些方面? 2、访问修饰符public,private,protected,以及不写(默认)时的区别? 3、String 是最基本的数据类型吗? 4、float f=3.4;是否正确? 5、short s1 = 1; s1 = ...

lanyu96
39分钟前
0
0
优雅的写出类

前言 虽然现在已经是ES6的时代,但是,还是有必要了解下ES5是怎么写一个类的。 本文详述JavaScript面向对象编程中的类写法,并分步骤讲述如何写出优雅的类。 一、例子 例子为一个轻提示组件T...

peakedness丶
44分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部