Stacked Autoencoder

最新推荐文章于 2024-06-24 18:14:21 发布
最新推荐文章于 2024-06-24 18:14:21 发布
阅读量374 收藏 2
点赞数
文章标签： 人工智能 python
原文链接：https://my.oschina.net/u/3579120/blog/1533516
版权

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

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

10012718_sMF5.png

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

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

10012719_kjE0.png

这样就把自编码器改成了深度结构了，即 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)，如下图所示：

10012719_Tcog.png

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

10012720_NamT.png

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

10012720_kGlH.png

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

10012721_IA2W.png

实验代码如下：

#!/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

知乎

转载于:https://my.oschina.net/u/3579120/blog/1533516

chuange6363
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python中stacked_栈式自动编码器(Stacked AutoEncoder)
weixin_39926311的博客
12-10 731
起源：自动编码器单自动编码器，充其量也就是个强化补丁版PCA，只用一次好不过瘾。仿照stacked RBM构成的DBN，提出Stacked AutoEncoder，为非监督学习在深度网络的应用又添了猛将。这里就不得不提 “逐层初始化”(Layer-wise Pre-training)，目的是通过逐层非监督学习的预训练，来初始化深度网络的参数，替代传统的随机小值方法。预训练完毕后，利用训练参数，再...
4. Stacked AutoEncoder（堆栈自动编码器）
weixin_30500105的博客
10-23 1073
1. AutoEncoder介绍 2. Applications of AutoEncoder in NLP 3. Recursive Autoencoder（递归自动编码器） 4. Stacked AutoEncoder（堆栈自动编码器） 1. 前言 深度学习的威力在于其能够逐层地学习原始数据的多种表达方式。每一层都以前一层的表达特征为基础，抽取出更加抽象，更加适合复杂的特征，然后做一些分类等任...
堆叠自动编码器(Stacked AutoEncoder)
u013250861的博客
12-19 3529
对于分类任务，往往在自动编码器顶端再添加一分类层（如Softmax层），并结合有标注的训练数据，在误差函数的指导下，对系统的参数进行微调，以使得整个网络能够完成所需的分类任务。降噪自编码器(Stacked Denoising Autoencoders)核心思想是，一个能够从中恢复出原始信号的表达未必是最好的，能够对“被污染/破坏”的原始数据编码、解码，然后还能恢复真正的原始数据，这样的特征才是好的。对我们来说，此时的h是至关重要的，因为它是在尽量不损失信息量的情况下，对原始数据的另一种表达。
Stacked autoencoder理论简析
热门推荐
xunileida的专栏
09-15 1万+
出处：http://www.fengchang.cc/post/92 上次总结了了PCA的东西，提到PCA的目的主要是降维。 stacked autoencoder也可以做类似的事情。然而讲stacked autoencoder之前，先讲其基础，简单版本：autoencoder， 先来建立直觉，这个东西思想很简单，也是利用神经网络的结构，最基础的一个形式如下： 假设从图的下方输入，...
堆栈自编码器 Stacked AutoEncoder
bbbeoy的专栏
08-23 2254
https://blog.csdn.net/qq_38640439/article/details/102624044?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.chan
【模型详解】AutoEncoder详解（七）——栈式自编码：Stacked AutoEncoder
roguesir的博客
12-05 5241
前言 之前介绍了AutoEncoder及其几种拓展结构，如DAE，CAE等，本篇博客介绍栈式自编码器。 模型介绍 普通的AE模型通过多层编码解码过程，得到输出，最小化输入输出的差异从而使模型学到有用的特征。但是这种AE结构又一个弊端：虽然经过了多次的特征提取，但对于目标函数的计算只有一次，那么，如果通过“栈化”AE结构进行逐层的贪婪训练得到的性能会不会比现有的要好呢？ 实际上，Stacked Au...
Deep Spatio-Temporal Representation for Detection of Road Accidents Using Stacked Autoencoder
wfl6666的博客
09-30 983
一种新的道路交通事故自动检测框架。该框架从原始像素强度的STVVs中自动学习特征表示（外观特征、运动特征），而不是传统的手工制作特征。采用异常检测思路。该框架使用对普通交通视频进行去噪的自动编码器（SADE）提取深度表示。根据重构误差和深度表示的可能性来确定事故发生的可能性。对于深度表示的可能性，使用one-class的SVM训练非监督模型。此外，利用车辆轨迹的交点来降低虚警率，增加整个系统的可靠性。
Deep learning：二十四(stacked autoencoder练习)
CHCH998的博客
08-18 1581
　　前言： 　　本次是练习2个隐含层的网络的训练方法，每个网络层都是用的sparse autoencoder思想，利用两个隐含层的网络来提取出输入数据的特征。本次实验验要完成的任务是对MINST进
matlab 实现 stacked Autoencoder 解决图像分类问题
03-27 5187
1. 加载数据到内存
LSTM-based Stacked Autoencoder for Multivariate time Series forecasting.pdf
03-31
Unsupervised pre-training of a Deep LSTM-based Stacked Autoencoder for Multivariate time Series forecasting problems Alaa Sagheer
Detection of double compressed AMR audio using stacked autoencoder
02-08
Detection of double compressed AMR audio using stacked autoencoder
UFLDL exercise7 Stacked Autoencoder
04-11
In this exercise, you will use a stacked autoencoder for digit classification.
UFLDL Exercise: Stacked autoencoder 栈式自编码
12-14
UFLDL Exercise: Stacked autoencoder（栈式自编码算法）matlab实验代码 可以直接运行
stacked Denoise autoencoder learning useful representation
11-14
该论文主要论证了无监督学习sdae算法的有效性，该算法极大的降低了SVM分类算法的分类损失值；缩小与DBN差距，某些方面甚至超越DBN
内积知识点小记
liujianjun1536500976的专栏
06-21 1319
对于两个向量a = [a₁, a₂,…, aₙ]和b = [b₁, b₂,…, bₙ]，它们的点积定义为：a·b = a₁b₁ + a₂b₂ + … + aₙbₙ。使用矩阵乘法，把（纵列）向量当作n×1 矩阵，点积也可以写为：a·b = (a^T) * b，这里的a^T指示矩阵a的转置。
Midjourney绘画提示词精选：提升AI艺术创作的秘诀
weixin_42132035的博客
06-22 1820
在AI艺术创作领域，MidJourney作为一款强大的绘画生成工具，受到了越来越多艺术家和设计师的青睐。通过提供简洁但富有创意的提示词，可以帮助MidJourney生成令人惊叹的艺术作品。在本文中，我们将分享一些精选的MidJourney绘画提示词，助你在AI艺术创作中取得更好的效果。
武汉星起航：挂牌上海股权中心，资本赋能共绘跨境电商繁荣新图景
m0_74145751的博客
06-22 453
同时，公司的品牌效应也将助力其在亚马逊市场上树立更加专业的形象，提升客户的信任度和忠诚度。这一里程碑式的举措不仅彰显了公司的雄厚实力，更为其在亚马逊市场的发展带来了诸多优势。武汉星起航的成功挂牌标志着其发展的新起点，凭借资本市场的强大支持，公司必将持续强化自身实力，扩大市场影响力，为客户提供卓越服务。展望未来，武汉星起航将继续引领行业创新，为亚马逊市场的繁荣贡献源源不断的动力，共同书写跨境电商的新辉煌篇章。这不仅为公司带来了更为充足的资金流，也为其在亚马逊市场的持续投入和快速发展提供了坚实的保障。
pytorch库 03 基础知识
最新发布
weixin_42830015的博客
06-24 776
pytorch库 03 基础知识
stacked autoencoder
05-05
Stacked autoencoder is a type of deep neural network that is used for unsupervised learning. It is composed of multiple layers of autoencoder neural networks, where the output of one layer serves as ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值