精华内容
下载资源
问答
  • 自动编码机

    千次阅读 2016-12-04 16:48:13
    自动编码机(Autodencoder) 自动编码机(Autoencoder)属于非监督学习,不需要对训练样本进行标记。自动编码机(Autoencoder)由三层网络组成,其中输入层神经元数量与输出层神经元数量相等,中间层神经元数量少于...

    自动编码机(Autodencoder)

    1. 自动编码机(Autoencoder)属于非监督学习,不需要对训练样本进行标记。自动编码机(Autoencoder)由三层网络组成,其中输入层神经元数量与输出层神经元数量相等,中间层神经元数量少于输入层和输出层。在网络训练期间,对每个训练样本,经过网络会在输出层产生一个新的信号,网络学习的目的就是使输出信号与输入信号尽量相似。自动编码机(Autoencoder)训练结束之后,其可以由两部分组成,首先是输入层和中间层,我们可以用这个网络来对信号进行压缩;其次是中间层和输出层,我们可以将压缩的信号进行还原。
    2. 自动编码机原理,假设我们输入一个 n 维的信号x(x[0,1]),经过输入层到达中间层,信号变为 y ,可以用如下公式表示:
      y=s(Wx+b)

      上式中中 s 是非线性函数,如sigmoid. W 是输入层到中间层的链接权值,b为中间层的bias. 信号 y 经过解码层解码,输出到n个神经元的输出层,信号变为 z ,如下公式:
      z=s(Wy+b)

      上式中中 s 是非线性函数,如sigmoid. W 是中间层到输出层的链接权值, b 为输出层的bias. z 被当作是x的预测。 通常情况下,权重矩阵 W 被限制为权重矩阵 W 的转置:W=WT.
    3. 当前的问题就是调整网络参数,使得最终输出的 z 与原始输入的信号x尽量的接近。根据输入数据的假设分布,有很多误差计算方法。可以使用典型的平方误差(squared error): L(xz)=||xz||2 . 如果输入的数据为位向量或者是位概率向量,可以使用交叉熵方法:
      LH(x,z)=k=1n[xklogzk+(1xk)log(1zk)]
    4. 我们希望中间层输出的分布式 y ,它能够捕获数据变化的主要因素的坐标数据。这类似于将数据投影到主成分上,可以获取数据变化的主要因素。如果我们将输入层与中间层之间的函数s变为线性函数,将最终输出层信号 z 与原始输入信号x的误差变为设为平方误差.则这个问题就变成了一个线性代数中的主成份分析问题了。假设中间层有 k 个节点,就变成由输入信号x的前k个主成份项,来近似表示原始输入信号.如果中间层的函数 s 是非线性的,自动编码机功能不同于PCA,具有捕获输入数据多模态方面的能力。当我们考虑堆叠多个编码器构建深度自动编码器时,不考虑PCA变得更加重要。
    5. 因为y可以视为 x <script type="math/tex" id="MathJax-Element-442">x</script>的有损压缩形式,通过我们的优化算法,可以对训练样本产生很好的压缩效果,同时在测试样本集上有很好的表现,但是我们并不能保证网络可以所有样本都有好的压缩效果。
    展开全文
  • 基于Spark的高效自动编码机
  • 自动编码机Auto-encoder AE 降噪自动编码器Denoising Auto-encoder dAE自动编码机(Auto-encoder, AE)自动编码机(Auto-encoder)属于非监督学习,不需要对训练样本进行标记。自动编码机(Auto-encoder)由三层网络...

    自动编码机(Auto-encoder, AE)

    自动编码机(Auto-encoder)属于非监督学习,不需要对训练样本进行标记。自动编码机(Auto-encoder)由三层网络组成,其中输入层神经元数量与输出层神经元数量相等,中间层神经元数量少于输入层和输出层。在网络训练期间,对每个训练样本,经过网络会在输出层产生一个新的信号,网络学习的目的就是使输出信号与输入信号尽量相似。自动编码机(Auto-encoder)训练结束之后,其可以由两部分组成,首先是输入层和中间层,我们可以用这个网络来对信号进行压缩;其次是中间层和输出层,我们可以将压缩的信号进行还原。
    Auto-encoder

    自动编码机原理,假设我们输入一个n维的信号 x(x[0,1]) ,经过输入层到达中间层,信号变为 y ,可以用如下公式表示:

    y=s(Wx+b)

    上式中中 s 是非线性函数,如sigmoid. W 是输入层到中间层的链接权值,b为中间层的bias. 信号y经过解码层解码,输出到 n 个神经元的输出层,信号变为z,如下公式:

    z=s(Wy+b)

    上式中中 s 是非线性函数,如sigmoid. W 是中间层到输出层的链接权值, b 为输出层的bias. z 被当作是x的预测。 通常情况下,权重矩阵 W 被限制为权重矩阵W的转置: W=WT .
    当前的问题就是调整网络参数,使得最终输出的z与原始输入的信号x尽量的接近。根据输入数据的假设分布,有很多误差计算方法。可以使用典型的平方误差(squared error): L(x,z)=||xz||2 . 如果输入的数据为位向量或者是位概率向量,可以使用交叉熵方法:
    LH(x,z)=k=1nln[xklogzk+(1xk)log(1zk)]

    我们希望中间层输出的分布式 y ,它能够捕获数据变化的主要因素的坐标数据。这类似于将数据投影到主成分上,可以获取数据变化的主要因素。如果我们将输入层与中间层之间的函数s变为线性函数,将最终输出层信号 z 与原始输入信号x的误差变为设为平方误差.则这个问题就变成了一个线性代数中的主成份分析问题了。假设中间层有 k 个节点,就变成由输入信号x的前 k 个主成份项,来近似表示原始输入信号.如果中间层的函数s是非线性的,自动编码机功能不同于 PCA ,具有捕获输入数据多模态方面的能力。当我们考虑堆叠多个编码器构建深度自动编码器时,不考虑 PCA 变得更加重要。
    因为y可以视为 x <script type="math/tex" id="MathJax-Element-186">x</script>的有损压缩形式,通过我们的优化算法,可以对训练样本产生很好的压缩效果,同时在测试样本集上有很好的表现,但是我们并不能保证网络可以所有样本都有好的压缩效果。

    降噪自动编码器(Denoising Auto-encoder, dAE)

    在神经网络模型训练阶段开始前,通过Auto-encoder对模型进行预训练可确定编码器W的初始参数值。然而,受模型复杂度、训练集数据量以及数据噪音等问题的影响,通过Auto-encoder得到的初始模型往往存在过拟合的风险。关于Auto-encoder的介绍请参考:自动编码器(Auto-encoder)。

    Denoising Autoencoder(降噪自动编码器)就是在Autoencoder的基础之上,为了防止过拟合问题而对输入的数据(网络的输入层)加入噪音,使学习得到的编码器W具有较强的鲁棒性,从而增强模型的泛化能力。Denoising Auto-encoder是Bengio在08年提出的,具体内容可参考其论文:Extracting and composing robust features with denoising autoencoders.
    论文中关于Denoising Auto-encoder的示意图如下,其中x是原始的输入数据,Denoising Auto-encoder以一定概率把输入层节点的值置为0,从而得到含有噪音的模型输入xˆ。这和dropout很类似,不同的是dropout是隐含层中的神经元置为0。

    Denoising Auto-encoder

    以这丢失的数据x’去计算y,计算z,并将z与原始x做误差迭代,这样,网络就学习了这个破损(原文叫Corruputed)的数据。
    这个破损的数据是很有用的,原因有二:
    其之一,通过与非破损数据训练的对比,破损数据训练出来的Weight噪声比较小。降噪因此得名。原因不难理解,因为擦除的时候不小心把输入噪声给×掉了。
    其之二,破损数据一定程度上减轻了训练数据与测试数据的代沟。由于数据的部分被×掉了,因而这破损数据一定程度上比较接近测试数据。(训练、测试肯定有同有异,当然我们要求同舍异)。

    Denoising Auto-encoder与人的感知机理类似,比如人眼看物体时,如果物体某一小部分被遮住了,人依然能够将其识别出来。
    人在接收到多模态信息时(比如声音,图像等),少了其中某些模态的信息有时也不会造成太大影响。
    Autoencoder的本质是学习一个相等函数,即网络的输入和重构后的输出相等,这种相等函数的表示有个缺点就是当测试样本和训练样本不符合同一分布,即相差较大时,效果不好,而Denoising Autoencoder在这方面的处理有所进步。

    展开全文
  • 传统的异常检测方法存在需要大量标注样本、不适应高维度时序数据等不足,提出一种基于LSTM自动编码机的工业系统异常检测方法。为克服现有方法依赖标注样本的不足,提出采用自动编码机,通过无监督的方式学习大量正常...
  • 由于手写数字边缘轮廓差异大造成书写风格的不同,为了提高识别准确度,通过在自动编码机中加入稀疏约束项和雅克比正则项,提出一种雅克比稀疏自动编码机(JSAE)的算法进行手写数字识别。加入稀疏约束项能够有效提取...
  • 一种基于卷积-自动编码机的三维特征自动学习 方法. 实验结果表明, 文中方法的特征学习速度比其他深度学习方法提高约2 个数量级, 且提取的特征在三维模型分 类、三维物体检测等任务中都取得了良好的结果.
  • 去噪自动编码机

    千次阅读 2016-12-04 20:26:39
    去噪自动编码机(Denoising Autoencoder) 自动编码机的主要作用是数据降维,提取特征。 原始输入xx 经过加权 (W,b)(W,b),映射函数(如:非线性函数Sigmoid)之后得到yy,在对yy反向加权映射回来成为zz。通过反复...

    去噪自动编码机(Denoising Autoencoder)

    1. 自动编码机的主要作用是数据降维,提取特征。 原始输入 x 经过加权 W,b,映射函数(如:非线性函数Sigmoid)之后得到 y ,在对y反向加权映射回来成为 z 。通过反复迭代两组W,b,使得误差函数最小,即尽可能保证 z 近似于x,即完美重构了 x .自动编码器,它没有使用数据标签来计算误差update参数,所以是无监督学习。其次,利用类似神经网络的双隐层的方式,简单粗暴地提取了样本的特征。Vincent在2010年的论文中做了研究,发现只要单组W就可以了。 我们在训练 W 过程中, W=WT , WW 成为Tied Weights. 实验证明 W 没必要去训练.
    2. 降噪自动编码器(Denoising Autoencoder). Vincent在2008年的论文中提出了AutoEncoder的改良版——dA。论文的标题叫 “Extracting and composing robust features with denoising autoencoders”。就是以一定概率分布(通常使用二项分布)去擦除原始输入矩阵,即每个值都随机置 0 , 这样看起来部分数据的部分特征是丢失了。以这丢失的数据x去计算 y ,计算z,并将 z 与原始x做误差迭代,这样,网络就学习了这个破损(原文叫Corruputed)的数据。这个破损的数据是很有用的,原因有二:其之一,通过与非破损数据训练的对比,破损数据训练出来的Weight噪声比较小。降噪因此得名。原因不难理解,因为擦除的时候不小心把输入噪声给擦掉了。其之二,破损数据一定程度上减轻了训练数据与测试数据的代沟。由于数据的部分被擦掉了,因而这破损数据, 一定程度上比较接近测试数据。(训练、测试肯定有同有异,当然我们要求同舍异)。这样训练出来的Weight的鲁棒性就提高了.破损的数据相当于一个简化的PCA,把特征做一个简单的降维预提取。
    展开全文
  • 基于LSTM自动编码机的短文本聚类方法.pdf
  • 自动编码机作为一种新兴的深层神经网络学习算法,在高维数据的降维和图像重构中取得了很好的效果。针对该方法在文本分类中重构出大量的对学习没有帮助的含噪数据,提出一种利用原型数据监督学习的改进模型,称做深层...
  • 首先在堆栈稀疏自动编码机中加入权重衰减项,再利用主成分分析方法对图像数据进行降维处理,然后根据主成分影像块内所有像元的第一主成分与中心像元间的差距对邻域信息进行排序、删除、重组和堆栈,最后将得到的空-谱...
  • 基于聚类和自动编码机的缺失数据填充算法.pdf
  • 深度学习 —— 降噪自动编码机

    千次阅读 2017-06-03 20:44:30
    降噪自动编码机 降噪自动编码机(dA)是传统自动编码机的延伸,在深度网络 [Vincent08]中被引入,我们先简单讨论一下自动编码机自动编码机 自动编码机接受输入,首先通过确定映射使用编码机把它映射到隐藏层的y...

    降噪自动编码机(dA)是传统自动编码机的延伸,在深度网络 [Vincent08]中被引入,我们先简单讨论一下自动编码机。

    自动编码机

    自动编码机接受输入\mathbf{x} \in [0,1]^d,首先通过确定映射使用编码机把它映射到隐藏层的y属于\mathbf{y} \in [0,1]^{d'},例如\mathbf{y} = s(\mathbf{W}\mathbf{x} + \mathbf{b})

    这里s是非线性例如sigmoid。隐藏的y,或代码然后通过解码机映射回与x有相同形状的重构z。这个映射与此前的转化类似,即\mathbf{z} = s(\mathbf{W'}\mathbf{y} + \mathbf{b'})


    这里,撇不代表矩阵转置。z被看作是给定代码y对于x的预测。可选的,逆映射的权重矩阵\mathbf{W'}可以被限制为前向映射的转置,即\mathbf{W'} = \mathbf{W}^T

    这被称为受限权重。该模型的参数通过优化使得平均重构误差最小。

    重构误差可以通过多种方式衡量,依赖于给定编码输入合适的分布假设。可以使用传统的平方差L(\mathbf{x} \mathbf{z}) = || \mathbf{x} -\mathbf{z} ||^2

    如果输入是比特向量或比特可能性向量,可以使用重构的交叉熵

    L_{H} (\mathbf{x}, \mathbf{z}) = - \sum^d_{k=1}[\mathbf{x}_k \log        \mathbf{z}_k + (1 - \mathbf{x}_k)\log(1 - \mathbf{z}_k)]

    期望编码y是一个能捕捉数据中变动主要因子坐标的分布体现。这与主成分映射能捕捉数据中变动主要因子类似。确实,如果只有单一线性隐藏层(代码)并且使用平均平方差标准训练网络,那么k隐藏单元学习映射数据中k主要成分跨度的输入。如果 隐藏层为非线性,自动编码机与PCA 表现不同,能够捕捉输入分布的不同模型面。这种不同在我们对叠多个编码机和相应解码机以构建深度编码机时尤为重要。

    由于y被是做是对x的简单压缩,因此不可能对所有x取得良好效果(损失小)。优化使它对于训练样本来说是良好压缩,并希望对其他输入也是如此,但并不是对任意输入都能这样。这是自动编码机所谓的泛化:对于与训练样本分布一致的测试样本它能给予低重构误差,但对于输入的随机样本一般重构误差较大。

    我们使用Theano来实现一个自动编码机

       def __init__(
            self,
            numpy_rng,
            theano_rng=None,
            input=None,
            n_visible=784,
            n_hidden=500,
            W=None,
            bhid=None,
            bvis=None
        ):
            """
            Initialize the dA class by specifying the number of visible units (the
            dimension d of the input ), the number of hidden units ( the dimension
            d' of the latent or hidden space ) and the corruption level. The
            constructor also receives symbolic variables for the input, weights and
            bias. Such a symbolic variables are useful when, for example the input
            is the result of some computations, or when weights are shared between
            the dA and an MLP layer. When dealing with SdAs this always happens,
            the dA on layer 2 gets as input the output of the dA on layer 1,
            and the weights of the dA are used in the second stage of training
            to construct an MLP.
    
            :type numpy_rng: numpy.random.RandomState
            :param numpy_rng: number random generator used to generate weights
    
            :type theano_rng: theano.tensor.shared_randomstreams.RandomStreams
            :param theano_rng: Theano random generator; if None is given one is
                         generated based on a seed drawn from `rng`
    
            :type input: theano.tensor.TensorType
            :param input: a symbolic description of the input or None for
                          standalone dA
    
            :type n_visible: int
            :param n_visible: number of visible units
    
            :type n_hidden: int
            :param n_hidden:  number of hidden units
    
            :type W: theano.tensor.TensorType
            :param W: Theano variable pointing to a set of weights that should be
                      shared belong the dA and another architecture; if dA should
                      be standalone set this to None
    
            :type bhid: theano.tensor.TensorType
            :param bhid: Theano variable pointing to a set of biases values (for
                         hidden units) that should be shared belong dA and another
                         architecture; if dA should be standalone set this to None
    
            :type bvis: theano.tensor.TensorType
            :param bvis: Theano variable pointing to a set of biases values (for
                         visible units) that should be shared belong dA and another
                         architecture; if dA should be standalone set this to None
    
    
            """
            self.n_visible = n_visible
            self.n_hidden = n_hidden
    
            # create a Theano random generator that gives symbolic random values
            if not theano_rng:
                theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
    
            # note : W' was written as `W_prime` and b' as `b_prime`
            if not W:
                # W is initialized with `initial_W` which is uniformely sampled
                # from -4*sqrt(6./(n_visible+n_hidden)) and
                # 4*sqrt(6./(n_hidden+n_visible))the output of uniform if
                # converted using asarray to dtype
                # theano.config.floatX so that the code is runable on GPU
                initial_W = numpy.asarray(
                    numpy_rng.uniform(
                        low=-4 * numpy.sqrt(6. / (n_hidden + n_visible)),
                        high=4 * numpy.sqrt(6. / (n_hidden + n_visible)),
                        size=(n_visible, n_hidden)
                    ),
                    dtype=theano.config.floatX
                )
                W = theano.shared(value=initial_W, name='W', borrow=True)
    
            if not bvis:
                bvis = theano.shared(
                    value=numpy.zeros(
                        n_visible,
                        dtype=theano.config.floatX
                    ),
                    borrow=True
                )
    
            if not bhid:
                bhid = theano.shared(
                    value=numpy.zeros(
                        n_hidden,
                        dtype=theano.config.floatX
                    ),
                    name='b',
                    borrow=True
                )
    
            self.W = W
            # b corresponds to the bias of the hidden
            self.b = bhid
            # b_prime corresponds to the bias of the visible
            self.b_prime = bvis
            # tied weights, therefore W_prime is W transpose
            self.W_prime = self.W.T
            self.theano_rng = theano_rng
            # if no input is given, generate a variable representing the input
            if input is None:
                # we use a matrix because we expect a minibatch of several
                # examples, each example being a row
                self.x = T.dmatrix(name='input')
            else:
                self.x = input
    
            self.params = [self.W, self.b, self.b_prime]

    注意我们将input作为一个参数传入,这样我们可以将不同层自动编码机连接以构建深度网络,k层的输出会成为k+1层的输入。

    现在我们来看隐藏表征和重构信号的计算

        
    def get_hidden_values(self, input):
            """ Computes the values of the hidden layer """
            return T.nnet.sigmoid(T.dot(input, self.W) + self.b)
    
       def get_reconstructed_input(self, hidden):
            """Computes the reconstructed input given the values of the
            hidden layer
    
            """
            return T.nnet.sigmoid(T.dot(hidden, self.W_prime) + self.b_prime)
    

    使用上述函数我们可以计算代价以及单步随机梯度下降的更新

     def get_cost_updates(self, corruption_level, learning_rate):
            """ This function computes the cost and the updates for one trainng
            step of the dA """
    
            tilde_x = self.get_corrupted_input(self.x, corruption_level)
            y = self.get_hidden_values(tilde_x)
            z = self.get_reconstructed_input(y)
            # note : we sum over the size of a datapoint; if we are using
            #        minibatches, L will be a vector, with one entry per
            #        example in minibatch
            L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)
            # note : L is now a vector, where each element is the
            #        cross-entropy cost of the reconstruction of the
            #        corresponding example of the minibatch. We need to
            #        compute the average of all these to get the cost of
            #        the minibatch
            cost = T.mean(L)
    
            # compute the gradients of the cost of the `dA` with respect
            # to its parameters
            gparams = T.grad(cost, self.params)
            # generate the list of updates
            updates = [
                (param, param - learning_rate * gparam)
                for param, gparam in zip(self.params, gparams)
            ]
    
            return (cost, updates)

    我们现在定义一个函数,以迭代的方式更新参数W,b和b_primes,以使代价最小。

     
    da = dA(
            numpy_rng=rng,
            theano_rng=theano_rng,
            input=x,
            n_visible=28 * 28,
            n_hidden=500
        )
    
        cost, updates = da.get_cost_updates(
            corruption_level=0.,
            learning_rate=learning_rate
        )
    
        train_da = theano.function(
            [index],
            cost,
            updates=updates,
            givens={
                x: train_set_x[index * batch_size: (index + 1) * batch_size]
            }
        )
    
        start_time = timeit.default_timer()
    
        ############
        # TRAINING #
        ############
    
        # go through training epochs
        for epoch in range(training_epochs):
            # go through trainng set
            c = []
            for batch_index in range(n_train_batches):
                c.append(train_da(batch_index))
    
            print('Training epoch %d, cost ' % epoch, numpy.mean(c, dtype='float64'))
    
        end_time = timeit.default_timer()
    
        training_time = (end_time - start_time)
    
        print(('The no corruption code for file ' +
               os.path.split(__file__)[1] +
               ' ran for %.2fm' % ((training_time) / 60.)), file=sys.stderr)
        image = Image.fromarray(
            tile_raster_images(X=da.W.get_value(borrow=True).T,
                               img_shape=(28, 28), tile_shape=(10, 10),
                               tile_spacing=(1, 1)))
        image.save('filters_corruption_0.png')
    
        # start-snippet-3
        #####################################
        # BUILDING THE MODEL CORRUPTION 30% #
        #####################################
    
        rng = numpy.random.RandomState(123)
        theano_rng = RandomStreams(rng.randint(2 ** 30))
    
        da = dA(
            numpy_rng=rng,
            theano_rng=theano_rng,
            input=x,
            n_visible=28 * 28,
            n_hidden=500
        )
    
        cost, updates = da.get_cost_updates(
            corruption_level=0.3,
            learning_rate=learning_rate
        )
    
        train_da = theano.function(
            [index],
            cost,
            updates=updates,
            givens={
                x: train_set_x[index * batch_size: (index + 1) * batch_size]
            }
        )
    
        start_time = timeit.default_timer()
    
        ############
        # TRAINING #
        ############
    
        # go through training epochs
        for epoch in range(training_epochs):
            # go through trainng set
            c = []
            for batch_index in range(n_train_batches):
                c.append(train_da(batch_index))
    
            print('Training epoch %d, cost ' % epoch, numpy.mean(c, dtype='float64'))
    
        end_time = timeit.default_timer()
    
        training_time = (end_time - start_time)
    
        print(('The 30% corruption code for file ' +
               os.path.split(__file__)[1] +
               ' ran for %.2fm' % (training_time / 60.)), file=sys.stderr)
        # end-snippet-3
    
        # start-snippet-4
        image = Image.fromarray(tile_raster_images(
            X=da.W.get_value(borrow=True).T,
            img_shape=(28, 28), tile_shape=(10, 10),
            tile_spacing=(1, 1)))
        image.save('filters_corruption_30.png')
        # end-snippet-4
    
        os.chdir('../')
    
    
    if __name__ == '__main__':
        test_dA()

    如果除了最小化重构误差外没有其他约束性条件,一个有n输入和n编码维度的自动编码机只会通过把输入映射到拷贝中来学习自身函数。这样的自动编码机无法将测试样本从其他输入设置中区分出来。

    令人吃惊的 [Bengio07] 实验报告建议在实践中,通过随机梯度下降训练,使用比输入多的隐藏单元的非线性自动编码机可以获得有用的表征。这里有用代表一个将编码作为输入的网络具有低区分误差。

    一个简单的解释是结合提早停止的随机梯度下降类似与参数的L2正则化。为实现连续输入的完美重构,一个具有单一隐藏层、非线性隐藏单元的自动编码机需要在第一(编码)层有非常小的权重,以使得隐藏单元的非线性限制在线性区域,而第二(解码) 层需要非常大的权重。对于二分输入,最小化重构误差也需要非常大的权重。考虑到隐性或显性正则化使得获得大权重解变得十分困难,优化函数显示编码只对与训练集中相似的样本有效,而这正是我们需要的。这表明,表征体现了训练集中的统计规则呈现,而不是简单的复制输入。

    还有其他方式防止有超过输入隐藏单元的自动编码机学习身份函数,在隐藏表征中捕捉输入中的有用信息。一种是稀疏化(使更多的隐藏单元为零或接近零) [Ranzato07] [Lee08]等做了很多这方面研究。另一种是在输入到重构的转化中加入随机性,这种方式在受限波尔兹机和降噪自动编码机中得到使用。

    降噪自动编码机

    降噪自动编码机背后的思想非常简单,强迫隐藏层学到抗干扰性更强的特征而不是简单的学到自己。我们训练自动编码机重建受损坏的输入。

    降噪自动编码机是使用了随机性的自动编码机。直觉上降噪自动编码机处理两个问题:尝试对输入进行编码(保存输入的信息),尝试随机的处理损坏问题,后者只能通过捕捉输入的统计依赖完成。降噪自动编码机可以从其他不同角度来理解(多折学习,随机运算,由下而上的信息理论,由上而下的生成模型)这些在[Vincent08] 中都有解释。

    [Vincent08] 中,随机损坏过程随机地将一些输入设置成零,有时可达一半。因此降噪自动编码机试图从未损坏(未缺失)值预测损坏(缺失)值,通过随机从损坏模式中选择子集。注意能从重置中预测任何变量子集是完全捕捉一组变量联合分布的充要条件(这也是Gibbs取样的原理)。

    将自动编码机转化为降噪自动编码机我们只要在输入中加入随机损失步骤。输入损失可以用很多方式,但我们使用最基本的随机使输入为零的方式。代码如下:

     
     def get_corrupted_input(self, input, corruption_level):
            """This function keeps ``1-corruption_level`` entries of the inputs the
            same and zero-out randomly selected subset of size ``coruption_level``
            Note : first argument of theano.rng.binomial is the shape(size) of
                   random numbers that it should produce
                   second argument is the number of trials
                   third argument is the probability of success of any trial
    
                    this will produce an array of 0s and 1s where 1 has a
                    probability of 1 - ``corruption_level`` and 0 with
                    ``corruption_level``
    
                    The binomial function return int64 data type by
                    default.  int64 multiplicated by the input
                    type(floatX) always return float64.  To keep all data
                    in floatX when floatX is float32, we set the dtype of
                    the binomial to floatX. As in our case the value of
                    the binomial is always 0 or 1, this don't change the
                    result. This is needed to allow the gpu to work
                    correctly as it only support float32 for now.
    
            """
            return self.theano_rng.binomial(size=input.shape, n=1,
                                            p=1 - corruption_level,
                                            dtype=theano.config.floatX) * input

    在多层自动编码机中dA的权重要在相应的sigmoid层共享,因此dA有指向共享参数的Theano变量。如果参数为None,则会重新构建。

    最终的降噪自动编码机代码如下:

    class dA(object):
        """Denoising Auto-Encoder class (dA)
    
        A denoising autoencoders tries to reconstruct the input from a corrupted
        version of it by projecting it first in a latent space and reprojecting
        it afterwards back in the input space. Please refer to Vincent et al.,2008
        for more details. If x is the input then equation (1) computes a partially
        destroyed version of x by means of a stochastic mapping q_D. Equation (2)
        computes the projection of the input into the latent space. Equation (3)
        computes the reconstruction of the input, while equation (4) computes the
        reconstruction error.
    
        .. math::
    
            \tilde{x} ~ q_D(\tilde{x}|x)                                     (1)
    
            y = s(W \tilde{x} + b)                                           (2)
    
            x = s(W' y  + b')                                                (3)
    
            L(x,z) = -sum_{k=1}^d [x_k \log z_k + (1-x_k) \log( 1-z_k)]      (4)
    
        """
    
        def __init__(
            self,
            numpy_rng,
            theano_rng=None,
            input=None,
            n_visible=784,
            n_hidden=500,
            W=None,
            bhid=None,
            bvis=None
        ):
            """
            Initialize the dA class by specifying the number of visible units (the
            dimension d of the input ), the number of hidden units ( the dimension
            d' of the latent or hidden space ) and the corruption level. The
            constructor also receives symbolic variables for the input, weights and
            bias. Such a symbolic variables are useful when, for example the input
            is the result of some computations, or when weights are shared between
            the dA and an MLP layer. When dealing with SdAs this always happens,
            the dA on layer 2 gets as input the output of the dA on layer 1,
            and the weights of the dA are used in the second stage of training
            to construct an MLP.
    
            :type numpy_rng: numpy.random.RandomState
            :param numpy_rng: number random generator used to generate weights
    
            :type theano_rng: theano.tensor.shared_randomstreams.RandomStreams
            :param theano_rng: Theano random generator; if None is given one is
                         generated based on a seed drawn from `rng`
    
            :type input: theano.tensor.TensorType
            :param input: a symbolic description of the input or None for
                          standalone dA
    
            :type n_visible: int
            :param n_visible: number of visible units
    
            :type n_hidden: int
            :param n_hidden:  number of hidden units
    
            :type W: theano.tensor.TensorType
            :param W: Theano variable pointing to a set of weights that should be
                      shared belong the dA and another architecture; if dA should
                      be standalone set this to None
    
            :type bhid: theano.tensor.TensorType
            :param bhid: Theano variable pointing to a set of biases values (for
                         hidden units) that should be shared belong dA and another
                         architecture; if dA should be standalone set this to None
    
            :type bvis: theano.tensor.TensorType
            :param bvis: Theano variable pointing to a set of biases values (for
                         visible units) that should be shared belong dA and another
                         architecture; if dA should be standalone set this to None
    
    
            """
            self.n_visible = n_visible
            self.n_hidden = n_hidden
    
            # create a Theano random generator that gives symbolic random values
            if not theano_rng:
                theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
    
            # note : W' was written as `W_prime` and b' as `b_prime`
            if not W:
                # W is initialized with `initial_W` which is uniformely sampled
                # from -4*sqrt(6./(n_visible+n_hidden)) and
                # 4*sqrt(6./(n_hidden+n_visible))the output of uniform if
                # converted using asarray to dtype
                # theano.config.floatX so that the code is runable on GPU
                initial_W = numpy.asarray(
                    numpy_rng.uniform(
                        low=-4 * numpy.sqrt(6. / (n_hidden + n_visible)),
                        high=4 * numpy.sqrt(6. / (n_hidden + n_visible)),
                        size=(n_visible, n_hidden)
                    ),
                    dtype=theano.config.floatX
                )
                W = theano.shared(value=initial_W, name='W', borrow=True)
    
            if not bvis:
                bvis = theano.shared(
                    value=numpy.zeros(
                        n_visible,
                        dtype=theano.config.floatX
                    ),
                    borrow=True
                )
    
            if not bhid:
                bhid = theano.shared(
                    value=numpy.zeros(
                        n_hidden,
                        dtype=theano.config.floatX
                    ),
                    name='b',
                    borrow=True
                )
    
            self.W = W
            # b corresponds to the bias of the hidden
            self.b = bhid
            # b_prime corresponds to the bias of the visible
            self.b_prime = bvis
            # tied weights, therefore W_prime is W transpose
            self.W_prime = self.W.T
            self.theano_rng = theano_rng
            # if no input is given, generate a variable representing the input
            if input is None:
                # we use a matrix because we expect a minibatch of several
                # examples, each example being a row
                self.x = T.dmatrix(name='input')
            else:
                self.x = input
    
            self.params = [self.W, self.b, self.b_prime]
    
        def get_corrupted_input(self, input, corruption_level):
            """This function keeps ``1-corruption_level`` entries of the inputs the
            same and zero-out randomly selected subset of size ``coruption_level``
            Note : first argument of theano.rng.binomial is the shape(size) of
                   random numbers that it should produce
                   second argument is the number of trials
                   third argument is the probability of success of any trial
    
                    this will produce an array of 0s and 1s where 1 has a
                    probability of 1 - ``corruption_level`` and 0 with
                    ``corruption_level``
    
                    The binomial function return int64 data type by
                    default.  int64 multiplicated by the input
                    type(floatX) always return float64.  To keep all data
                    in floatX when floatX is float32, we set the dtype of
                    the binomial to floatX. As in our case the value of
                    the binomial is always 0 or 1, this don't change the
                    result. This is needed to allow the gpu to work
                    correctly as it only support float32 for now.
    
            """
            return self.theano_rng.binomial(size=input.shape, n=1,
                                            p=1 - corruption_level,
                                            dtype=theano.config.floatX) * input
    
        def get_hidden_values(self, input):
            """ Computes the values of the hidden layer """
            return T.nnet.sigmoid(T.dot(input, self.W) + self.b)
    
        def get_reconstructed_input(self, hidden):
            """Computes the reconstructed input given the values of the
            hidden layer
    
            """
            return T.nnet.sigmoid(T.dot(hidden, self.W_prime) + self.b_prime)
    
        def get_cost_updates(self, corruption_level, learning_rate):
            """ This function computes the cost and the updates for one trainng
            step of the dA """
    
            tilde_x = self.get_corrupted_input(self.x, corruption_level)
            y = self.get_hidden_values(tilde_x)
            z = self.get_reconstructed_input(y)
            # note : we sum over the size of a datapoint; if we are using
            #        minibatches, L will be a vector, with one entry per
            #        example in minibatch
            L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)
            # note : L is now a vector, where each element is the
            #        cross-entropy cost of the reconstruction of the
            #        corresponding example of the minibatch. We need to
            #        compute the average of all these to get the cost of
            #        the minibatch
            cost = T.mean(L)
    
            # compute the gradients of the cost of the `dA` with respect
            # to its parameters
            gparams = T.grad(cost, self.params)
            # generate the list of updates
            updates = [
                (param, param - learning_rate * gparam)
                for param, gparam in zip(self.params, gparams)
            ]
    
            return (cost, updates)

    汇总

    通过dA类构建并训练一个实例非常简单

     # allocate symbolic variables for the data
        index = T.lscalar()    # index to a [mini]batch
        x = T.matrix('x')  # the data is presented as rasterized images
    
      #####################################
        # BUILDING THE MODEL CORRUPTION 30% #
        #####################################
    
        rng = numpy.random.RandomState(123)
        theano_rng = RandomStreams(rng.randint(2 ** 30))
    
        da = dA(
            numpy_rng=rng,
            theano_rng=theano_rng,
            input=x,
            n_visible=28 * 28,
            n_hidden=500
        )
    
        cost, updates = da.get_cost_updates(
            corruption_level=0.3,
            learning_rate=learning_rate
        )
    
        train_da = theano.function(
            [index],
            cost,
            updates=updates,
            givens={
                x: train_set_x[index * batch_size: (index + 1) * batch_size]
            }
        )
    
        start_time = timeit.default_timer()
    
        ############
        # TRAINING #
        ############
    
        # go through training epochs
        for epoch in range(training_epochs):
            # go through trainng set
            c = []
            for batch_index in range(n_train_batches):
                c.append(train_da(batch_index))
    
            print('Training epoch %d, cost ' % epoch, numpy.mean(c, dtype='float64'))
    
        end_time = timeit.default_timer()
    
        training_time = (end_time - start_time)
    
        print(('The 30% corruption code for file ' +
               os.path.split(__file__)[1] +
               ' ran for %.2fm' % (training_time / 60.)), file=sys.stderr)
    

    为了了解网络学习到的内容我们图示过滤器(由权重矩阵定义)。注意这里我们忽略了偏差并且将权重经倍数常数处理(权重转化为0和1之间)。

    我们使用PIL中的tile_raster_images,下列代码将过滤器保存为图像:

      
     image = Image.fromarray(tile_raster_images(
            X=da.W.get_value(borrow=True).T,
            img_shape=(28, 28), tile_shape=(10, 10),
            tile_spacing=(1, 1)))
        image.save('filters_corruption_30.png')

    运行代码

    python dA.py
    

    不使用噪声的过滤器

    _images/filters_corruption_0.png

    使用30%噪声的过滤器

    _images/filters_corruption_30.png



    展开全文
  • 基于原型自动编码机的GPS空时自适应抗干扰方法.pdf
  • 变分自动编码机(VAE)理解和实现(Tensorflow)

    万次阅读 多人点赞 2018-05-04 10:21:58
    你需要知道的: 自动编码机Auto-Encoder (AE)由两部分encoder和decoder组成,encoder输入x数据,输出潜在变量z,decoder输入z然后输出一个x’,目的是让x’...变分自动编码机VAE是自动编码机的一种扩展,它假设输...
  • 一种自动编码机与K-means相结合的高光谱图像聚类方法.pdf
  • 行业分类-物理装置-基于全连接自动编码机的瞬态图像的数据增强方法.zip
  • 在上一篇博文中,我们讨论了去噪自动编码机(dA),...在本节中,我们将讨论去噪自动编码机(dA)的主要应用,即组成堆叠自动编码机(SdA),我们将以MNIST手写字母识别为例,用堆叠自动编码机(SdA)来解决这一问题。
  • 截至目前为止,我们所讨论的...在这一篇博文,我们将介绍稍微不同的神经网络架构,即被称为自动编码机(Autoencoder)。与前述我们所讨论的神经网络不同,自动编码器(Autoencoder)属于非监督学习,不需要对训练样本
  • 自动编码机是一种出入层节点数等于输出层节点数的三层神经网络,只有中间一层隐藏层。
  • 非常强大的java编码机,可自由的选择生成源码 与自身的项目完全没有任何瓜葛,不会影响自身的项目
  • 在明白了去噪自动编码机(dA)的理论之后,在本篇博文中,我们将讨论用Theano来实现一个去噪自动编码机。通过上篇博文的讨论,我们知道去噪自动编码机(dA)工作主要有四步组成:第一步是向原始输入信号中加入随机...
  • 利用CFS聚类算法对不完整数据集进行聚类,对降噪自动编码模型进行改进,根据聚类结果,利用改进的自动编码模型对缺失数据进行填充。为了使得CFS聚类算法能够对不完整数据集进行聚类,提出一种部分距离策略,用于度量...
  • sparse autoencoder(稀疏自动编码机)

    千次阅读 2015-01-05 16:16:17
    上述的自动编码机试图学习到一个函数 不难看出一个trival 的solution 就是学习到一个identity function, 但是这并不是我们想要的的, 因为这样我们什么也没有学到。 但是通过给网络施加一些constraint, 或者给...
  • 多层编码机由多个自动编码机和分类层组成,自动编码机进行逐层地非监督预训练,最后整个网络进行fine-tuning实现最后的 非监督与训练 监督fine-tuning 代码实现 建立 Sda类,通过构造函数将结构...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 280,243
精华内容 112,097
关键字:

自动编码机