一个非常好的理解autoencoders的例子

最新推荐文章于 2024-07-11 10:47:26 发布
最新推荐文章于 2024-07-11 10:47:26 发布
阅读量1.8k 收藏 2
点赞数 1

深度学习有一个重要的概念叫autoencoder，这是个什么东西呢，本文通过一个例子来普及这个术语。

    Autoencoders

    简单来说autoencoder是一个压缩编码器，也就是对input的一坨东西通过变换，输出和input一样的东西。例如input是一个鸡，ouput也是一个鸡，input是一个鸭，output也是一个鸭。学术一点说就是找到一个函数能够使得 Function(input) = input,叫做identity function。如上图所示，即学习Hw,b(x)=x。



    但这和深度学习有什么关系呢？ 这就要说到压缩编码，我们都知道input需要有一种编码形式，如果我们能在函数内部找到一个更简洁的编码形式，那么这个变换过程就等价于学习到了一种压缩表示的函数，能够少量的存储形式来表示原本较复杂的但信息冗余较大的表示形式。



    我们下面的代码中举了一个精彩的例子(这个例子是从同学的一次实验中直接受启发，我只是按照自己的理解实现了一把，例子非原创）。在这个例子中，input是4个不同的数字，分别是

    (0,0,0,1)可以看作1

    (0,0,1,0)可以看作2

    (0,1,0,0)可以看作3

    (1,0,0,0)可以看作4

    因为所有的input只有这4种，因此其实用4个bit是不经济的，存在压缩表示的可能性，比如2个bit就可以表示这4个不同的数。



    那么我们设计了输入层是4+1（4个脚接受4bit编码的input，1个脚是常数项，这个用来做先验的）；隐藏层2+1（因为我们实现已经知道2个bit就够了，所以2个隐藏层，具有足够的表达能力）；输出层4（为了能让输出和输入保持一致）

  

    通过数轮迭代，我们看到如下的情况

    (0,0,0,1)->（0.99,0.09）->(0.06,0.00,0.01,0.91)

    (0,0,1,0)->（0.85,0.99）->(0.00,0.07,0.90,0.07)

    (0,1,0,0)->（0.01,0.67）->(0.06,0.87,0.11,0.00)

    (1,0,0,0)->（0.12,0.00）->(0.89,0.10,0.00,0.02)

     input_layer hidden_layer     output_layer

    

     hidden层的编码恰好可以看作是

     （0.99,0.09）  1,0

     （0.85,0.99）  1,1

     （0.01,0.67）  0,1

     （0.12,0.00）  0,0



     也就是说输入的（0，0，0，1）可以被1，0 压缩表示，最终4bit的信息，可以用2bit表示，当然还需要保持边的权重，但这些边权重只需要一份，在输入足够复杂的时候，压缩表示是有价值的。

 

      那压缩表示有什么价值呢？比如一组广告，一条新闻，人看了挺好，压缩表示后，人看起来就不爽了，恰恰是人看着不爽了，机器就好处理了，下回再说。。

 

        其他相关可参见美军参考资料：

        http://ufldl.stanford.edu/wiki/index.php/Autoencoders_and_Sparsity

 

以下是实验代码，水平有限，仅供参考。

 

#include <iostream>

#include "math.h"

using namespace std;

double d = 0.4;

double function_g(double x)

{

        doubleex = pow(2.718281828,x);

        returnex/(1+ex);

}

 

double input[4][5]={{0,0,0,1,1}, //{0,0,0,1} {1}

                    {0,0,1,0,1},

                    {0,1,0,0,1},

                    {1,0,0,0,1}};

 

double edge_1[2][5];

double edge_2[4][3];

double first_layer[5];

double hidden_layer[3]={0,0,1};

double output_layer[4];

 

double diff()

{

        doubleret = 0.0;

        for(inti=0;i<4;++i)

        {

                ret+= (output_layer[i]-first_layer[i])*(output_layer[i]-first_layer[i]);

        }

        returnret;

}

void count_second_l( )

{

        for(inti=0;i<2;++i)

        {

                hidden_layer[i]= 0;

                for(intj=0;j<5;++j)

                {

                        hidden_layer[i]+= first_layer[j]*edge_1[i][j];

                }

                hidden_layer[i]= function_g(hidden_layer[i]);

        }

        return;

}

void count_last_l()

{

        for(inti=0;i<4;++i)

        {

                output_layer[i]= 0;

                for(intj=0;j<3;++j)

                {

                        output_layer[i]+= hidden_layer[j]*edge_2[i][j];

                }

                output_layer[i]= function_g(output_layer[i]);

        }

        return;

}

double total_diff()

{

        doubleret = 0.0;

        for(int j=0;j<4;++j)

        {

                first_layer[0]=input[j][0];

                first_layer[1]=input[j][1];

                first_layer[2]=input[j][2];

                first_layer[3]=input[j][3];

                first_layer[4]=input[j][4];

                count_second_l();

                count_last_l();

                ret+= diff();

        }

        returnret;

}

 

int main(void)

{

        for(inti=0;i<2;++i)

                for(intj=0;j<5;++j)

                        edge_1[i][j]= ((i+j)%4+0.1)/10;        //initialize eachedges between first_layers and hidden layers

 

         for(inti=0;i<4;++i)

                for(intj=0;j<3;++j)

                        edge_2[i][j]= ((i+j)%4+0.1)/10;        //initialize eachedges between hidden_layers and output_layers

 

        for(inti=0;i<40000;++i)                                //iterate40000 times

        {

                doubleorigin_diff=total_diff();

                doubledirection_1[2][5],direction_2[4][3];

                for(inti=0;i<2;++i)

                        for(intj=0;j<5;++j)

                        {

                                doubletmp = edge_1[i][j] ;

                                edge_1[i][j]+= d * origin_diff;

                                count_second_l();

                                count_last_l();

                                doublediff2 = total_diff();

                                direction_1[i][j]= origin_diff - diff2;

                                edge_1[i][j]= tmp;

                        }

                for(inti=0;i<4;++i)

                        for(intj=0;j<3;++j)

                        {

                                doubletmp = edge_2[i][j] ;

                                edge_2[i][j]+= d * origin_diff;

                                count_second_l();

                                count_last_l();

                                doublediff2 = total_diff();

                                direction_2[i][j]= origin_diff - diff2;

                                edge_2[i][j]= tmp;

                        }

                for(inti=0;i<2;++i)

                        for(intj=0;j<5;++j)

                        {

                                edge_1[i][j]+= d * origin_diff * direction_1[i][j];

                        }

                for(inti=0;i<4;++i)

                        for(intj=0;j<3;++j)

                        {

                                edge_2[i][j]+= d * origin_diff * direction_2[i][j];

                        }

 

                doubled = 0.0;                

                for(int j=0;j<4;++j)

                {

                        first_layer[0]=input[j][0];

                        first_layer[1]=input[j][1];

                        first_layer[2]=input[j][2];

                        first_layer[3]=input[j][3];

                        first_layer[4]=input[j][4];

                        count_second_l();

                        count_last_l();

                        d+= diff();

                        cout<<"####################"<<endl;

                        cout<<"input:\t"<<first_layer[0]<<"\t"<<first_layer[1]<<"\t"<<first_layer[2]<<"\t"<<first_layer[3]<<endl;

                        cout<<"output:\t"<<output_layer[0]<<"\t"<<output_layer[1]<<"\t"<<output_layer[2]<<"\t"<<output_layer[3]<<endl;

                        cout<<"hidden:\t"<<hidden_layer[0]<<"\t"<<hidden_layer[1]<<endl;

                        cout<<"####################"<<endl;

                }

                cout<<"diff_sum:"<<d<<endl;

        }

}

 

PAUL_shuo
关注
VAE 自编码器模型简介：学习高维数据的分布，并将其映射到一个低维空间 Variational Autoencoders Explained
程序员光剑
08-05 986
Variational autoencoder（VAE）是一种自编码器模型，它可以用来学习高维数据的分布，并将其映射到一个低维空间。这是因为VAE可以捕获输入数据中的所有不确定性，并且可以使用生成模型进行后续预测或重建。VAE的本质是通过找到一种有效的方式来学习高维数据空间的概率分布，从而使得潜在变量能够代表原始数据的某种隐含模式。这种隐含模式可能包含一些重要的特征或者结构信息。VAE使用了变分推断方法，使得潜在变量能够生成新的数据样本，并且能够很好地拟合输入数据上的分布。
笔记(总结)-自编码器（Autoencoders）
ZSY的大后台
12-19 2061
AE 自编码器（下简记为AE）为一类特殊的神经网络，该网络输入维度等于输出维度，通过网络隐层的复杂神经元结构，尝试学习数据的内在特征（pattern），从而达到特征提取、数据降维、生成新数据等多种目的。 简单的AE和MLP类似，except输入维度等于输出维度。此时输入数据的标签即为自身，模型的损失函数cost=cost(output, input)，用来评估输出是否很好地重新构建了输入。 ...
tensorflow Auto-Encoder实现
weixin_42529756的博客
03-13 146
Auto-Encoder import os import tensorflow as tf import numpy as np from tensorflow import keras from tensorflow.keras import Sequential, layers from PIL import Image from matplotlib import pyplot as plt tf.random.set_seed(22) np.random..
自动编码器（Autoencoders）
最新发布
bunny___的博客
07-11 718
神经网络以各种形状和大小存在，并且通常以其输入和输出数据类型为特征。例如，图像分类器是用卷积神经网络构建的。它们将图像作为输入，并输出类的概率分布。 自动编码器是一类输入与输出相同的神经网络。它们的工作原理是将输入压缩到潜在空间表示中，然后从该表示中重建输出。
Auto-Encoders
糖公子没来过的博客
09-13 121
AUTOENCODERS
weixin_62728271的博客
02-14 249
一、Supervised Learning 二、Auto-Encoders 三、Dropout AutoEncoders
[计算机视觉]Stacked Capsule Autoencoders
Bajo的博客
02-03 721
Stacked Capsule Autoencoders 前言 由Hinton提出的Capsule的概念从最早的Transforming auto-encoders的首次提出，到Dynamic Routing Between Capsules的首次实现，再到EM routing的优化。如今的Stacked Capsule Autoencoders已经是第三个版本的CapsNet。2020年AAAI，Hinton也调侃这一版Capsule才是对的，把之前的都忘了吧。所以，接下来我们就一起看看这一版的Caps
PCA、AutoEncoders 、VAE、GAN
Kukafee的博客
06-26 1134
PCA 摘自原文：https://blog.csdn.net/program_developer/article/details/80632779 相关背景：对含有多个变量的数据进行观测，收集大量数据后进行分析寻找规律。多变量数据集增加了数据采集的工作量。在很多情形下，许多变量之间可能存在相关性，增加了问题分析的复杂性。如果分别对每个指标进行分析，分析往往是孤立的，不能完...
图解Transformer（完整版）
热门推荐
龙心尘
01-17 40万+
审校：百度NLP、龙心尘 翻译：张驰、毅航、Conrad 原作者：Jay Alammar 原链接：https://jalammar.github.io/illustrated-transformer/ 编者按：前一段时间谷歌推出的BERT模型在11项NLP任务中夺得SOTA结果，引爆了整个NLP界。而BERT取得成功的一个关键因素是Transformer的强大作用。谷歌的Transformer模型...
PCA和自动编码器：每个人都能理解的算法
gongdiwudu的专栏
08-07 5364
本文的主要重点是提供主成分分析 （PCA） 和自动编码器数据转换技术的直观信息。我不打算深入研究支撑这些模型的数学理论，因为已经有大量的资源可用。
tensorflow_autoencoder_demo.py例子
01-28
官方例子，深度学习专用，机器学习专用，代码简单，一看就会(tensorflow autoencoder demo)
keras_variational_autoencoder例子
01-28
keras 官方例子，深度学习专用，机器学习专用，代码简单，
深度学习算法中的自动编码器（Autoencoders）
牛肉胡辣汤
09-20 1725
自动编码器（Autoencoders）是一种无监督学习算法，在深度学习领域中被广泛应用。它可以通过将输入数据进行编码和解码来重构数据，从而学习数据的低维表示。自动编码器可以用于特征提取、降维和数据重建等任务，在图像处理、文本处理和推荐系统等领域都有广泛的应用。自动编码器是一种强大的深度学习算法，可以用于特征提取、降维和数据重建等任务。它的无监督学习特性使得它适用于大量无标签数据的处理。通过合理设计和训练自动编码器，我们可以从数据中挖掘出有用的信息，为后续的机器学习任务提供更好的输入。
高级人工智能之自编码器Auto-encoders
蒋大钊的博客
10-27 1474
梳理高级人工智能课上关于自编码器Auto-encoder的概念理解
自动编码器家族Autoencoders
2301_78486960的博客
04-02 933
在2014年，除了对抗学习这一重大的进步之外，图像生成领域还诞生了著名的“从图像到图像”的生成模型：变分自动编码器（Variational Autoencoders，VAE）。这一架构是从自动编码器（Autoencoders）衍生而来，它与线性层所构成的GAN在能力上较为相似，经过适当训练之后它可以生成难辨真假的手写数字与人脸数据。然而，变分自动编码器的“声势”却不像生成对抗网络那样浩大，其一是因为生成对抗网络有巨大的研究潜力，其二是由于研究者们早已对于类似于变分自动编码器的各类编码器架构非常熟悉了。
利用Theano理解深度学习——Auto Encoder
null的专栏
11-29 5565
注：本系列是基于参考文献中的内容，并对其进行整理，注释形成的一系列关于深度学习的基本理论与实践的材料，基本内容与参考文献保持一致，并对这个专题起名为“利用Theano理解深度学习”系列，若文中有任何问题欢迎咨询。本文提供PDF版本，欢迎索取。“利用Theano理解深度学习”系列分为44个部分，这是第二部分，在第一部分中的算法主要是监督学习算法，在这部分中主要是无监督学习算法和半监督学习算法，主要包括
Perceptron
tang0057的博客
10-09 310
（笔记总结需要！目前粗糙潦草，后期会不断修改。若对您阅读造成不便，望请见谅！！）5. Perceptron
定义一个损失函数用于一维Wasserstein AutoEncoders代码keras
05-24
以下是一个例子，其中定义了一个损失函数，该函数使用Wasserstein距离作为度量，并同时考虑重构误差和潜在空间中的距离： ```python from keras import backend as K def wasserstein_loss(y_true, y_pred): # ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值