精华内容
下载资源
问答
  • 深度置信网络

    2019-11-20 07:46:56
    深度置信网络

    深度置信网络

    展开全文
  • 深度置信网络的Python实现例子keras
  • 详细的介绍了受限玻尔兹曼机(RBM)和深度置信网络(DBN),看完你就知道什么是深度置信网络了。侵删。
  • 深度置信网络DBN的matlab算法实现,可直接运行,程序运行采样的数据库为MNIST手写数字数据库。
  • 基于matlab2019a编写的程序 深度置信网络时间序列预测,已经调好的程序,换了数据就可以用。无标签训练 划分训练集和测试集
  • 深度学习 —— 深度置信网络

    万次阅读 2017-06-03 22:00:32
    深度置信网络 [Hinton06]提出了RBMs可以堆叠起来以贪婪的方式进行训练以构成深度置信网络(DBN)。DBNs是学习提取训练数据深度结构表征的图模型,为观察到的向量x和l隐藏层h_k的联合分布建模如下:其中是k层已RBM的...
    [Hinton06]提出了RBMs可以堆叠起来以贪婪的方式进行训练以构成深度置信网络(DBN)。DBNs是学习提取训练数据深度结构表征的图模型,为观察到的向量x\ell隐藏层h^k的联合分布建模如下:
    

    P(x, h^1, \ldots, h^{\ell}) = \left(\prod_{k=0}^{\ell-2} P(h^k|h^{k+1})\right) P(h^{\ell-1},h^{\ell})

    其中x=h^0P(h^{k-1} | h^k)是k层已RBM的隐藏单元为条件的可见单元的条件性分布。P(h^{\ell-1}, h^{\ell})是在RBM顶层的可见-隐藏联合分布。图示如下:

    _images/DBN3.png

    DBN和RBM可使用贪婪的层际无监督训练原则是每层的基石,过程如下:

    1、将第一层作为RBM训练,将x =h^{(0)}输入作为可见层。

    2、将第一层获取的输入表征作为第二层数据。两种方式存在,可以选择平均激活 p(h^{(1)}=1|h^{(0)})或者p(h^{(1)}|h^{(0)})样本。

    3、将第二层作为RBM训练,将转化后的数据(样本或平均激活)作为训练样本(该RBM层的可见部分)。

    4、重复2和3,选择满意的层数,每次向上传递样本或平均值。

    5、细调该深度结构的所有参数,参考DBN指数相似代理,或有监督训练标准(加入额外的学习机器把习得的表征转化为有监督的预测,例如线形分类)。

    这里,我们仅关注通过有监督的梯度下降细调。特别的我们使用逻辑回归分类器去分类输入x,基于DBN最终隐藏层的输出。细调因此通过负指数相似成本函数的有监督梯度下降实现。考虑到有监督的梯度对每层的权重和隐藏层偏差是非空(空代表每个RBM的可见偏差),这个过程相当于使用非监督训练策略取得权重和隐藏层偏差来初始化深度MLP参数。

    论证贪婪的层际预训练

    为什么这种算法有效 ?假设一个2层DBN有隐藏层h1和h2,相应的权重为W1和W2,[Hinton06]证明了logp(x)可以写成\log p(x) = &KL(Q(h^{(1)}|x)||p(h^{(1)}|x)) + H_{Q(h^{(1)}|x)} + \\            &\sum_h Q(h^{(1)}|x)(\log p(h^{(1)}) + \log p(x|h^{(1)})).

    KL(Q(h^{(1)}|x) || p(h^{(1)}|x))代表了第一个独立RBM的后验Q(h^{(1)}|x)和该层由整体DBN(考虑了顶层RBM定义的先验)定义的概率P之间的KL分离。

    H_{Q(h^{(1)}|x)}Q(h^{(1)}|x)分布的交叉熵。

    如果我们初始化隐藏层使 W^{(2)}={W^{(1)}}^TQ(h^{(1)}|x)=p(h^{(1)}|x)则KL分离项为空。如果我们习得第一层RBM然后固定参数W^{(1)},依据W^{(2)}优化公式则只能提高p(x)的可能性。

    注意如果我们分离各项仅依赖W^{(2)},我们得到

    \sum_h Q(h^{(1)}|x)p(h^{(1)})

    依据W^{(2)}优化训练RBM第二阶段,使用Q(h^{(1)}|x)作为训练分布,x是从第一个RBM训练分布中取样获得。

    实现

    在Theano中实现DBNs,我们使用在受限伯尔曼机种定义的类。可以看到DBN的代码与SdA非常相似,因为两者都涉及非监督层际预训练后进行深度MLP的有监督细调。主要不同是使用RBM类而不是dA类。

    我们首先定义DBN类,它将储存MLP的层和相应的RBMs。既然我们使用RBMs来初始化MLP,代码尽可能的区分用来初始化网络的RBMs和用来分类的MLP。

    class DBN(object):
        """Deep Belief Network
    
        A deep belief network is obtained by stacking several RBMs on top of each
        other. The hidden layer of the RBM at layer `i` becomes the input of the
        RBM at layer `i+1`. The first layer RBM gets as input the input of the
        network, and the hidden layer of the last RBM represents the output. When
        used for classification, the DBN is treated as a MLP, by adding a logistic
        regression layer on top.
        """
    
        def __init__(self, numpy_rng, theano_rng=None, n_ins=784,
                     hidden_layers_sizes=[500, 500], n_outs=10):
            """This class is made to support a variable number of layers.
    
            :type numpy_rng: numpy.random.RandomState
            :param numpy_rng: numpy random number generator used to draw initial
                        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 n_ins: int
            :param n_ins: dimension of the input to the DBN
    
            :type hidden_layers_sizes: list of ints
            :param hidden_layers_sizes: intermediate layers size, must contain
                                   at least one value
    
            :type n_outs: int
            :param n_outs: dimension of the output of the network
            """
    
            self.sigmoid_layers = []
            self.rbm_layers = []
            self.params = []
            self.n_layers = len(hidden_layers_sizes)
    
            assert self.n_layers > 0
    
            if not theano_rng:
                theano_rng = MRG_RandomStreams(numpy_rng.randint(2 ** 30))
    
            # allocate symbolic variables for the data
    
            # the data is presented as rasterized images
            self.x = T.matrix('x')
    
            # the labels are presented as 1D vector of [int] labels
            self.y = T.ivector('y')

    self.sigmoid_layers将储存前项传递图,用来构建MLP,而self.rbm_layers将储存用来预训练MLP每层的RBMs。

    下一步我们构建n_layers sigmoid层(我们使用多层感知机里引入的HiddenLayer类,仅把其中非线性部分从tanh改为逻辑函数s(x) = \frac{1}{1+e^{-x}})和n_layers RBMs,n_layers是模型的深度。我们把sigmoid鞥连接起来构建MLP,并以共享权重矩阵和相应sigmoid层隐藏偏差的方式来构建RBM。

         
     for i in range(self.n_layers):
                # construct the sigmoidal layer
    
                # the size of the input is either the number of hidden
                # units of the layer below or the input size if we are on
                # the first layer
                if i == 0:
                    input_size = n_ins
                else:
                    input_size = hidden_layers_sizes[i - 1]
    
                # the input to this layer is either the activation of the
                # hidden layer below or the input of the DBN if you are on
                # the first layer
                if i == 0:
                    layer_input = self.x
                else:
                    layer_input = self.sigmoid_layers[-1].output
    
                sigmoid_layer = HiddenLayer(rng=numpy_rng,
                                            input=layer_input,
                                            n_in=input_size,
                                            n_out=hidden_layers_sizes[i],
                                            activation=T.nnet.sigmoid)
    
                # add the layer to our list of layers
                self.sigmoid_layers.append(sigmoid_layer)
    
                # its arguably a philosophical question...  but we are
                # going to only declare that the parameters of the
                # sigmoid_layers are parameters of the DBN. The visible
                # biases in the RBM are parameters of those RBMs, but not
                # of the DBN.
                self.params.extend(sigmoid_layer.params)
    
                # Construct an RBM that shared weights with this layer
                rbm_layer = RBM(numpy_rng=numpy_rng,
                                theano_rng=theano_rng,
                                input=layer_input,
                                n_visible=input_size,
                                n_hidden=hidden_layers_sizes[i],
                                W=sigmoid_layer.W,
                                hbias=sigmoid_layer.b)
                self.rbm_layers.append(rbm_layer)

    然后我们将最后的逻辑回归层堆叠上去。我们使用逻辑回归里介绍的LogisticRegression类。

     
     self.logLayer = LogisticRegression(
                input=self.sigmoid_layers[-1].output,
                n_in=hidden_layers_sizes[-1],
                n_out=n_outs)
            self.params.extend(self.logLayer.params)
    
            # compute the cost for second phase of training, defined as the
            # negative log likelihood of the logistic regression (output) layer
            self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
    
            # compute the gradients with respect to the model parameters
            # symbolic variable that points to the number of errors made on the
            # minibatch given by self.x and self.y
            self.errors = self.logLayer.errors(self.y)

    同时提供为每个RBMs生成训练函数的方法。他们作为列表返回,元素i是执行RBM第i层单步训练的函数。

      def pretraining_functions(self, train_set_x, batch_size, k):
            '''Generates a list of functions, for performing one step of
            gradient descent at a given layer. The function will require
            as input the minibatch index, and to train an RBM you just
            need to iterate, calling the corresponding function on all
            minibatch indexes.
    
            :type train_set_x: theano.tensor.TensorType
            :param train_set_x: Shared var. that contains all datapoints used
                                for training the RBM
            :type batch_size: int
            :param batch_size: size of a [mini]batch
            :param k: number of Gibbs steps to do in CD-k / PCD-k
    
            '''
    
            # index to a [mini]batch
            index = T.lscalar('index')  # index to a minibatch

    为了能在训练时更改训练速率,我们将Theano变量连接到默认值

       
      learning_rate = T.scalar('lr')  # learning rate to use
    
            # begining of a batch, given `index`
            batch_begin = index * batch_size
            # ending of a batch given `index`
            batch_end = batch_begin + batch_size
    
            pretrain_fns = []
            for rbm in self.rbm_layers:
    
                # get the cost and the updates list
                # using CD-k here (persisent=None) for training each RBM.
                # TODO: change cost function to reconstruction error
                cost, updates = rbm.get_cost_updates(learning_rate,
                                                     persistent=None, k=k)
    
                # compile the theano function
                fn = theano.function(
                    inputs=[index, theano.In(learning_rate, value=0.1)],
                    outputs=cost,
                    updates=updates,
                    givens={
                        self.x: train_set_x[batch_begin:batch_end]
                    }
                )
                # append `fn` to the list of functions
                pretrain_fns.append(fn)
    
            return pretrain_fns

    现在任一函数pretrain_fns[i]接受声明index和可选的lr-学习速率。同样的DBN类构建一个细调的方法函数。

     
      def build_finetune_functions(self, datasets, batch_size, learning_rate):
            '''Generates a function `train` that implements one step of
            finetuning, a function `validate` that computes the error on a
            batch from the validation set, and a function `test` that
            computes the error on a batch from the testing set
    
            :type datasets: list of pairs of theano.tensor.TensorType
            :param datasets: It is a list that contain all the datasets;
                            the has to contain three pairs, `train`,
                            `valid`, `test` in this order, where each pair
                            is formed of two Theano variables, one for the
                            datapoints, the other for the labels
            :type batch_size: int
            :param batch_size: size of a minibatch
            :type learning_rate: float
            :param learning_rate: learning rate used during finetune stage
    
            '''
    
            (train_set_x, train_set_y) = datasets[0]
            (valid_set_x, valid_set_y) = datasets[1]
            (test_set_x, test_set_y) = datasets[2]
    
            # compute number of minibatches for training, validation and testing
            n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
            n_valid_batches //= batch_size
            n_test_batches = test_set_x.get_value(borrow=True).shape[0]
            n_test_batches //= batch_size
    
            index = T.lscalar('index')  # index to a [mini]batch
    
            # compute the gradients with respect to the model parameters
            gparams = T.grad(self.finetune_cost, self.params)
    
            # compute list of fine-tuning updates
            updates = []
            for param, gparam in zip(self.params, gparams):
                updates.append((param, param - gparam * learning_rate))
    
            train_fn = theano.function(
                inputs=[index],
                outputs=self.finetune_cost,
                updates=updates,
                givens={
                    self.x: train_set_x[
                        index * batch_size: (index + 1) * batch_size
                    ],
                    self.y: train_set_y[
                        index * batch_size: (index + 1) * batch_size
                    ]
                }
            )
    
            test_score_i = theano.function(
                [index],
                self.errors,
                givens={
                    self.x: test_set_x[
                        index * batch_size: (index + 1) * batch_size
                    ],
                    self.y: test_set_y[
                        index * batch_size: (index + 1) * batch_size
                    ]
                }
            )
    
            valid_score_i = theano.function(
                [index],
                self.errors,
                givens={
                    self.x: valid_set_x[
                        index * batch_size: (index + 1) * batch_size
                    ],
                    self.y: valid_set_y[
                        index * batch_size: (index + 1) * batch_size
                    ]
                }
            )
    
            # Create a function that scans the entire validation set
            def valid_score():
                return [valid_score_i(i) for i in range(n_valid_batches)]
    
            # Create a function that scans the entire test set
            def test_score():
                return [test_score_i(i) for i in range(n_test_batches)]
    
            return train_fn, valid_score, test_score

    注意返回的valid_score和test_score不是Theano函数而是Python函数。

    总结

    以下代码构建了深度置信网络

      numpy_rng = numpy.random.RandomState(123)
        print('... building the model')
        # construct the Deep Belief Network
        dbn = DBN(numpy_rng=numpy_rng, n_ins=28 * 28,
                  hidden_layers_sizes=[1000, 1000, 1000],
                  n_outs=10)

    训练该网络有两个阶段(1)层际预训练(2)细调

    在预训练阶段我们遍历网络每一层。每一层我们使用Theano确定i层 RBM的输入并执行单步CD-k。训练次数由pretraining_epochs给定固定值。

     #########################
        # PRETRAINING THE MODEL #
        #########################
        print('... getting the pretraining functions')
        pretraining_fns = dbn.pretraining_functions(train_set_x=train_set_x,
                                                    batch_size=batch_size,
                                                    k=k)
    
        print('... pre-training the model')
        start_time = timeit.default_timer()
        # Pre-train layer-wise
        for i in range(dbn.n_layers):
            # go through pretraining epochs
            for epoch in range(pretraining_epochs):
                # go through the training set
                c = []
                for batch_index in range(n_train_batches):
                    c.append(pretraining_fns[i](index=batch_index,
                                                lr=pretrain_lr))
                print('Pre-training layer %i, epoch %d, cost ' % (i, epoch), end=' ')
                print(numpy.mean(c, dtype='float64'))
    
        end_time = timeit.default_timer()

    细调与多层感知机介绍的内容相似,不同在于我们使用build_finetune_functions函数。

    执行代码

    python code/DBN.py
    

    使用默认函数,代码运行100次预训练,微批次大小为10,相当于执行500000次无监督参数更新。我们使用无监督学习速率0.01,监督学习速率0.1。DBN自身包含3个隐藏层,每层1000个单元。使用提前停止,46次监督训练后,该设置去的最小验证误差1.27,相应测试误差为1.34。

    在Intel(R) Xeon(R) CPU X5560 2.80GHz,使用多线程MKL库(在4个核上运行),预训练花费615分钟,平均为2.05分钟/层×次。细调只需要101分钟,或约2.20分钟/次。

    超参数由最优化验证误差获得。我们测试了无监督学习速率

    和无监督学习速率除提前停止外没有使用正则化,也没有对预训练更新优化。

    技巧

    提高运行速度的一个方式(有足够的内存) 是一次传入i层数据集并计算表征,给定i-1层固定。从训练地一层RBM开始。一旦训练完成,可以计算数据集中每个样本的隐藏单元值并将他们存为新数据集用以训练第2层的RBM。依次类推。这样避免了计算中间(隐藏层)表征,但会加大内存使用。


    展开全文
  • 针对单一形态数据在音乐情感分类方面的局限性,文中提出了基于深度置信网络的多特征融合音乐分类算法。首先对音乐信号从多个角度进行特征向量的提取,形成多特征数据并进行融合。同时针对音乐情感分类,将传统的深度...
  • 深度置信网络和已有的浅层算法相结合,提出基于深度置信网络的4-CBA软测量模型。深度置信网络是一种典型的深度学习算法,该算法在特征学习方面优势显著。根据实验结果,基于深度置信网络的软测量模型能够很好地...
  • DBN深度置信网络的实现

    千次阅读 热门讨论 2018-09-12 20:58:14
    深度置信网络(DBN)是由一系列的玻尔兹曼机(RBM)进行叠加组成的。 代码实现DBN的过程,请参考matlab的深度学习工具箱:DeepLearnToolbox  。 而关于深度置信网络的原理部分,请参考大神 peghoty的...

    “`

    深度置信网络(DBN)是由一系列的玻尔兹曼机(RBM)进行叠加组成的。

    代码实现DBN的过程,请参考matlab的深度学习工具箱:DeepLearnToolbox  。

    而关于深度置信网络的原理部分,请参考大神 peghoty的博客:http://blog.csdn.net/itplus/article/details/19168937

    那么接下来就是自己利用deeplearntoolbox来编写自己的深度置信网络(DBN)了。

    DBN函数,包含功能:初始化DBN参数,并进行训练DBN网络,之后将DBN扩展为NN,并对NN进行了相应的初始化,训练以及测试

    1. function DBN(train_x,train_y,test_x,test_y)
    2. %单纯的DBN只是一个NN网络,它返回的是一个训练好的网络,而不是对测试样本的一个评估
    3. %所以,在这个程序中,我们是没有看到输出的结果的
    4. %要进行预测,必须要有逻辑回归或者softmax回归才行,因为,这样才能够对测试样本进行评估
    5. %初始化参数,层数
    6. x = double(train_x)/255;
    7. opts.numepochs = 1;%迭代次数
    8. opts.batchsize = 100;%批次处理的大小
    9. opts.momentum = 0;%动量(调整梯度)
    10. opts.learn_r = 1;%学习率
    11. n = size(x,2);%输入的节点数
    12. dbn.layers = [100 100];%隐层的层数以及节点数
    13. dbn.layers = [n,dbn.layers];%输入层+隐层
    14. %对每层的权重和偏置进行初始化
    15. for u = 1:numel(dbn.layers)-1 %u表示隐层层数
    16. dbn.rbm{u}.learn_r = opts.learn_r;
    17. dbn.rbm{u}.momentum = opts.momentum;
    18. dbn.rbm{u}.W = zeros(dbn.layers(u+1),dbn.layers(u));%784*100的权重矩阵
    19. dbn.rbm{u}.vW = zeros(dbn.layers(u+1),dbn.layers(u));%更新参数用
    20. dbn.rbm{u}.b = zeros(dbn.layers(u), 1);%b为可见层的偏置
    21. dbn.rbm{u}.vb = zeros(dbn.layers(u), 1);
    22. dbn.rbm{u}.c = zeros(dbn.layers(u + 1), 1);%c为隐层的偏置
    23. dbn.rbm{u}.vc = zeros(dbn.layers(u + 1), 1);
    24. end
    25. %初始化参数完毕
    26. %训练
    27. u = numel(dbn.rbm);%隐层的玻尔兹曼机数
    28. dbn.rbm{1} = rbmtrain1(dbn.rbm{1},x,opts);%训练第一层rbm
    29. for i = 2:u
    30. P = repmat(dbn.rbm{i - 1}.c’, size(x, 1), 1) + x * dbn.rbm{i - 1}.W’;
    31. x = 1./(1+exp(-P));
    32. dbn.rbm{i} = rbmtrain1(dbn.rbm{i},x,opts);
    33. end
    34. figure; visualize(dbn.rbm{1}.W’); % Visualize the RBM weights
    35. %训练完毕,并打印特征图
    36. %展开为nn,利用BP算法进行参数微调
    37. outputsize = 10; %MNIS数据库,所以最后一层输出只能有10
    38. nn.layers = [dbn.layers,outputsize];%nn是DBN展开的,不过还需要其他的一些参数.nn的size表示层数
    39. nn.n = numel(nn.layers);
    40. nn.activation_function = ‘tanh_opt’; % 激活函数
    41. nn.learningRate = 2; % 学习速率
    42. nn.momentum = 0.5; % 动量,与梯度有关
    43. nn.scaling_learningRate = 1; % Scaling factor for the learning rate (each epoch)
    44. nn.weightPenaltyL2 = 0; % L2 regularization
    45. nn.nonSparsityPenalty = 0; % Non sparsity penalty
    46. nn.sparsityTarget = 0.05; % Sparsity target
    47. nn.inputZeroMaskedFraction = 0; % Used for Denoising AutoEncoders
    48. nn.testing = 0; % Internal variable. nntest sets this to one.
    49. nn.output = ‘sigm’; % 输出是线性、softmax、还是sigm?
    50. nn.dropoutFraction = 0; % Dropout level (http://www.cs.toronto.edu/~hinton/absps/dropout.pdf)
    51. for i = 2:nn.n
    52. nn.W{i - 1} = (rand(nn.layers(i),nn.layers(i-1)+1)-0.5)*2*4*sqrt(6/(nn.layers(i)+nn.layers(i-1)));
    53. %注意,这儿必须进行权重初始化,因为输出层的权重并没有设置,而且在后面会W会被DBN训练好的权重覆盖
    54. nn.vW{i - 1} = zeros(size(nn.W{i - 1}));
    55. nn.p{i} = zeros(1,nn.layers(i));%该参数是用来进行稀疏的
    56. end
    57. for i =1: numel(dbn.rbm)%利用了DBN调整的权重
    58. nn.W{i} = [dbn.rbm{i}.c dbn.rbm{i}.W];%注意,我们已经将偏置和权重一块放入nn.W{i}中
    59. end
    60. nn.activation_function = ‘sigm’;
    61. %到此,DBN扩展为NN并且进行了初始化
    62. %接着进行训练
    63. x1 = double(train_x) / 255;
    64. test_x = double(test_x) / 255;
    65. y1 = double(train_y);
    66. test_y = double(test_y);
    67. nn = nntrain1(nn, x1, y1, opts);
    68. %训练完毕
    69. %进行样本测试
    70. labels = nnpredict1(nn,test_x);
    71. [dummy,expected] = max(test_y,[],2);
    72. bad = find(labels~= expected);
    73. er = numel(bad) / size(test_x,1);
    74. assert(er < 0.10, ‘Too big error’);
    75. end

    rbmtrain1函数:这个过程就是对DBN进行训练的过程,要注意的是,对DBN的训练仅仅只是让DBN进行特征学习,而这个过程DBN是无法进行决策,判断的,其训练过程中参数的更新主要依赖样本的变化,返回的是一个进过训练的网络(这个网络还没有输出)。

    1. function rbm = rbmtrain1(rbm,x,opts)
    2. assert(isfloat(x),'x must be a float');
    3. assert(all(x(:)>=0) && all(x(:)<=1),'all data in x must be in [0,1]');
    4. m =size(x,1); %返回x的行数,即样本数量
    5. numbatches = m/opts.batchsize;%每 batchsize个样本作为一组
    6. assert(rem(numbatches,1)==0,'numbatches not int');
    7. for i = 1:opts.numepochs
    8. seq = randperm(m);%seq 是1-m的随机数序列
    9. err = 0 ;%误差
    10. for l = 1:numbatches
    11. batch = x(seq((l-1)*opts.batchsize +1:l*opts.batchsize),:);%取x的100个样本
    12. %下面的过程是进行GIBBS采样,也算是CD-k算法的实现
    13. v1 = batch;%v1表示可见层的初始化,共100个样本
    14. P1 = repmat(rbm.c', opts.batchsize, 1) + v1 * rbm.W';
    15. h1 = double(1./(1+exp(-P1)) > rand(size(P1)));
    16. P2 = repmat(rbm.b', opts.batchsize, 1) + h1 * rbm.W;
    17. v2 = double(1./(1+exp(-P2)) > rand(size(P2)));
    18. P3 = repmat(rbm.c', opts.batchsize, 1) + v2 * rbm.W';
    19. h2 = 1./(1+exp(-P3));
    20. %参数的更新
    21. c1 = h1' * v1;
    22. c2 = h2' * v2;
    23. rbm.vW = rbm.momentum * rbm.vW + rbm.learn_r * (c1 - c2) / opts.batchsize;
    24. rbm.vb = rbm.momentum * rbm.vb + rbm.learn_r * sum(v1 - v2)' / opts.batchsize;
    25. rbm.vc = rbm.momentum * rbm.vc + rbm.learn_r * sum(h1 - h2)' / opts.batchsize;
    26. rbm.W = rbm.W + rbm.vW;
    27. rbm.b = rbm.b + rbm.vb;
    28. rbm.c = rbm.c + rbm.vc;
    29. err = err + sum(sum((v1 - v2) .^ 2)) / opts.batchsize;
    30. end
    31. disp(['epoch ' num2str(i) '/' num2str(opts.numepochs) '. Average reconstruction error is: ' num2str(err / numbatches)]);
    32. end

    nntrain1函数:主要包含了前馈传播,后向传播(BP算法实现),参数更新,以及性能评估等过程

    1. function nn = nntrain1( nn, x, y, opts,val_x,val_y)
    2. assert(nargin == 4 || nargin == 6,'number of input arguments must be 4 or 6');
    3. loss.train.e = [];%%保存的是对训练数据进行前向传递,根据得到的网络输出值计算损失,并保存
    4. %在nneval那里有改变,loss.train.e(end + 1) = nn.L;
    5. loss.train.e_frac = []; %保存的是:对分类问题,用训练数据对网络进行测试,
    6. %首先用网络预测得到预测分类,用预测分类与实际标签进行对比,保存错分样本的个数
    7. loss.val.e = [];%有关验证集
    8. loss.val.e_frac = [];
    9. opts.validation = 0;
    10. if nargin == 6%nargin表示参数个数,4个或者6个(val_x,val_y是可选项)
    11. opts.validation =1;
    12. end
    13. fhandle = [];
    14. if isfield(opts,'plot') && opts.plot == 1
    15. fhandle = figure();
    16. end
    17. m = size(x,1);
    18. batchsize = opts.batchsize;%批次处理的数目 为100
    19. numepochs = opts.numepochs;%迭代次数 为1
    20. numbatches = m/batchsize;%批次处理的次数
    21. assert(rem(numbatches,1) == 0,'numbatches must be int');
    22. L = zeros(numepochs * numbatches,1);%L用来存储每个训练小批量的平方误差
    23. n = 1;%n作为L的索引
    24. for i=1:numepochs
    25. tic;% tic用来保存当前时间,而后使用toc来记录程序完成时间,
    26. %差值为二者之间程序运行的时间,单位:s
    27. seq = randperm(m);
    28. %每次选择一个batch进行训练,每次训练都讲更新网络参数和误差,由nnff,nnbp,nnapplygrads实现:
    29. for l = 1 : numbatches
    30. batch_x = x(seq((l-1) * batchsize +1 : l * batchsize),:);
    31. %每100个为一组进行处理
    32. %添加噪声
    33. if(nn.inputZeroMaskedFraction ~= 0)%nn参数设置中有,设置为0
    34. batch_x = batch_x.*(rand(size(batch_x)) > nn.inputZeroMaskedFraction);
    35. end
    36. batch_y = y(seq((l-1) * batchsize +1 : l * batchsize),:);
    37. nn = nnff1(nn,batch_x,batch_y);%进行前向传播
    38. nn = nnbp1(nn);%后向传播
    39. nn = nnapplygrads1(nn);%进行梯度下降
    40. L(n) = nn.L;%记录批次的损失,n作为下标
    41. n = n+1;
    42. end
    43. t = toc;
    44. %用nneval和训练数据,评价网络性能
    45. if opts.validation == 1
    46. loss = nneval1(nn, loss, x, y, val_x, val_y);
    47. str_perf = sprintf('; Full-batch train mse = %f, val mse = %f', loss.train.e(end), loss.val.e(end));
    48. else
    49. %在nneval函数里对网络进行评价,继续用训练数据,并得到错分的样本数和错分率,都存在了loss里
    50. loss = nneval1(nn, loss, x, y);
    51. str_perf = sprintf('; Full-batch train err = %f', loss.train.e(end));
    52. end
    53. %下面是画图函数
    54. if ishandle(fhandle)
    55. nnupdatefigures1(nn, fhandle, loss, opts, i);
    56. end
    57. disp(['epoch ' num2str(i) '/' num2str(opts.numepochs) '. Took ' num2str(t) ' seconds' '. Mini-batch mean squared error on training set is ' num2str(mean(L((n-numbatches):(n-1)))) str_perf]);
    58. nn.learningRate = nn.learningRate * nn.scaling_learningRate;
    59. end
    60. end

    nnff1函数:进行前馈传播,即就是有输入的数据进行计算隐层节点,输出节点的输出

    1. function nn = nnff1( nn,x,y )
    2. %前馈传播
    3. n = nn.n;%网络层数
    4. m = size(x,1);%样本个数:应该为100
    5. x = [ones(m,1) x];%应该是100*785数组,第一列全为1,后784列为样本值
    6. nn.a{1} = x;%nn.a{i}表示第i层的输出值,所以a{n}也就表示输出层的结果
    7. for i = 2 :n-1
    8. switch nn.activation_function
    9. case 'sigm'
    10. P = nn.a{i - 1} * nn.W{i - 1}';%注意:这儿已经把偏置计算进去了
    11. %因为在前面展开的时候,将偏置放在了nn.W{i} = [dbn.rbm{i}.c dbn.rbm{i}.W];中
    12. %并且对训练样本添加了一列,这一列就对应这偏置的计算
    13. nn.a{i} = 1./(1+exp(-P));
    14. case 'tanh_opt'
    15. P = nn.a{i - 1} * nn.W{i - 1}';
    16. nn.a{i} = 1.7159*tanh(2/3.*P);
    17. end
    18. %dropout
    19. if(nn.dropoutFraction > 0)
    20. if(nn.testing)
    21. nn.a{i} = aa.a{i}.* (1 - nn.dropoutFraction);
    22. else
    23. nn.dropOutMask{i} = (rand(size(nn.a{i}))>nn.dropoutFraction);
    24. nn.a{i} = nn.a{i}.*nn.dropOutMask{i};
    25. end
    26. end
    27. %计算使用稀疏性的指数级激活
    28. if(nn.nonSparsityPenalty>0)
    29. nn.p{i} = 0.99 * nn.p{i} + 0.01 * mean(nn.a{i}, 1);
    30. end
    31. nn.a{i} = [ones(m,1) nn.a{i}];
    32. end
    33. switch nn.output
    34. case 'sigm'
    35. P = nn.a{n - 1} * nn.W{n - 1}';
    36. nn.a{n} = 1./(1+exp(-P));
    37. case 'linear'
    38. nn.a{n} = nn.a{n-1} * nn.W{n-1}';
    39. case 'softmax'
    40. nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';
    41. nn.a{n} = exp(bsxfun(@minus, nn.a{n}, max(nn.a{n},[],2)));
    42. nn.a{n} = bsxfun(@rdivide, nn.a{n}, sum(nn.a{n}, 2));
    43. end
    44. %损失
    45. nn.e= y-nn.a{n};%损失,差值
    46. switch nn.output%除m是为了平均误差-也可以认为是单个样本的误差
    47. case {'sigm','linear'}
    48. nn.L = 1/2 * sum(sum(nn.e .^2)) /m;
    49. case 'softmax'
    50. nn.L = -sum(sum(y .* log(nn.a{n}))) /m;
    51. end
    52. end

    nnbp1函数:后向传播即就是BP算法的实现:
    1. function nn= nnbp1( nn )
    2. %进行后向传播算法
    3. n = nn.n;
    4. sparsityError = 0;
    5. switch nn.output%本步骤表示输出层单个节点的差值(-(yi-ai)*f'(zi)),即就是BP第二步,第一步是前馈传播,计算各节点的输出值
    6. case 'sigm'
    7. d{n} = -nn.e .*(nn.a{n} .* (1-nn.a{n}));
    8. case {'softmax','linear'}
    9. d{n} = -nn.e;
    10. end
    11. for i = (n-1):-1:2%d_act表示激活函数的导数
    12. switch nn.activation_function
    13. case 'sigm'
    14. d_act = nn.a{i} .*(1-nn.a{i});
    15. case 'tanh-opt'
    16. d_act = 1.7159 * 2/3 * (1 - 1/(1.7159)^2 * nn.a{i}.^2);
    17. end
    18. if(nn.nonSparsityPenalty>0)%稀疏时有用
    19. pi = repmat(nn.p{i}, size(nn.a{i}, 1), 1);
    20. sparsityError = [zeros(size(nn.a{i},1),1) nn.nonSparsityPenalty * (-nn.sparsityTarget ./ pi + (1 - nn.sparsityTarget) ./ (1 - pi))];
    21. end
    22. if i+1 == n%BP算法的第三步
    23. d{i} = (d{i + 1} * nn.W{i} + sparsityError) .* d_act;
    24. else
    25. d{i} = (d{i + 1}(:,2:end) * nn.W{i} + sparsityError) .* d_act;
    26. %注意,在这儿第一列是偏置,所以要进行移除
    27. end
    28. if(nn.dropoutFraction>0)
    29. d{i} = d{i} .* [ones(size(d{i},1),1) nn.dropOutMask{i}];
    30. end
    31. end
    32. for i = 1 : (n-1)%由于每层的节点数是不一样的,所以需要用除以size(d{i])来求平均节点误差
    33. if i+1 == n%dW表示的是梯度
    34. nn.dW{i} = (d{i + 1}' * nn.a{i}) / size(d{i + 1}, 1);
    35. else
    36. nn.dW{i} = (d{i + 1}(:,2:end)' * nn.a{i}) / size(d{i + 1}, 1);
    37. end
    38. end
    39. end

    nnapplygras1d函数:在BP算法后,进行参数的更新,该函数和nnbp1在整个DBN过程中可以认为是微调阶段

    1. function nn = nnapplygrads1(nn)
    2. %更新参数的函数
    3. for i=1:(nn.n-1)%的W本身包括偏置和权重
    4. if(nn.weightPenaltyL2>0)%L2处罚用
    5. dW = nn.dW{i} + nn.weightPenaltyL2 * [zeros(size(nn.W{i},1),1) nn.W{i}(:,2:end)];
    6. else
    7. dW = nn.dW{i};
    8. end
    9. dW = nn.learningRate * dW;
    10. if(nn.momentum > 0)
    11. nn.vW{i} = nn.momentum * nn.vW{i} + dW;
    12. dW = nn.vW{i};
    13. end
    14. nn.W{i} = nn.W{i} - dW;
    15. end
    16. end
    nneval1函数:实现性能的评估
    1. function [ loss ] = nneval1(nn, loss, x, y, val_x, val_y)
    2. %评估网路性能
    3. assert(nargin ==4 || nargin == 6,'Wrong number of argument');
    4. nn.testing = 1;
    5. %训练性能
    6. nn = nnff1(nn,x,y);
    7. loss.train.e(end+1) = nn.L;
    8. %验证性能
    9. if nargin == 6
    10. nn = nnff1(nn,val_x,val_y);
    11. loss.val.e(end+1) = nn.L;
    12. end
    13. nn.testing = 0;
    14. %错分类率
    15. if strcmp(nn.output,'softmax')
    16. [er_train, dummy] = nntest(nn, train_x, train_y);
    17. loss.train.e_frac(end+1) = er_train;
    18. if nargin == 6
    19. [er_val, dummy] = nntest(nn, val_x, val_y);
    20. loss.val.e_frac(end+1) = er_val;
    21. end
    22. end
    23. end

    最后就是进行数据的测试

    1. function labels = nnpredict1(nn,x)
    2. nn.testing = 1;
    3. nn = nnff1(nn, x, zeros(size(x,1), nn.layers(end)));
    4. nn.testing = 0;
    5. [dummy, i] = max(nn.a{end},[],2);
    6. labels = i;
    7. end

    到此,整个代码的实现过程结束

    代码运行结果:3层隐层,各100个节点,numepochs=1


    2层隐层,各100 节点,numepochs=10:


    总结:DBN在运行过程中只是进行特征学习,而无法进行决策,所以在进行DBN训练完成后,需要将DBN扩展为NN,即添加输出层(根据分类结果天天输出层的节点数)。然后,用训练好的DBN的参数初始化NN的参数,进而在进行传统的NN训练,就是进行前馈传播,后向传播等,这样的过程就是完成了DBN的预训练-微调过程。这样之后才可以进行判断,分类等。


    以上是我个人在学习DBN过程的一点小心得,若有不足,恳请指正。

                </div>
    

    展开全文
  • 深度置信网络是个包含多个受限玻尔兹曼机的深层架构。针对深度置信网络分类时由于受限玻尔兹曼机的输入一般是二值向量而造成的信息的丢失从而使分类效果降低的问题,提出了通过在sigmoid单元中增加噪声来将输入缩放...
  • 根据深度置信网络的特点,从数据集变量的异常数据剔除、训练数据批次的选择、参数调优的迭代周期以及在线学习训练等方面对模型性能进行优化和改善,从而使得深度置信网络能够充分挖掘数据集的信息特征,达到有效地...
  • 深度置信网络学习总结

    千次阅读 2016-12-22 14:56:49
    深度置信网络学习总结 目录 深度置信网络学习总结... 1 一、 蒙特卡洛方法和Gibbs 采样... 2 1.1 随机模拟(蒙特卡罗方法)的作用... 2 3.2蒙特卡洛的基础——马氏链及其平稳分布... 3 3.3 举个例子——...



    深度置信网络学习总结

    目录

    深度置信网络学习总结... 1

    一、 蒙特卡洛方法和Gibbs 采样... 2

    1.1 随机模拟(蒙特卡罗方法)的作用... 2

    3.2蒙特卡洛的基础——马氏链及其平稳分布... 3

    3.3 举个例子——蒙特卡洛方法的使用步骤... 7

    3.4 Gibbs 采样... 10

    二.限制波尔兹曼机... 13

    2.1限制波尔兹曼机(RBM)... 13

    2.1.1 RBM的使用说明... 13

    2.1.2 RBM的用途... 15

    2.2限制波尔兹曼机(RBM)能量模型... 16

    2.2.1 能量模型定义... 16

    3.2.2 能量模型作用... 16

    2.3从能量模型到概率... 18

    2.3.1 从能量函数到概率... 18

    2.3.2 从概率到极大似然... 19

    2.4求解极大似然... 20

    2.5用到的抽样方法... 23

    3.6马尔科夫蒙特卡罗简介... 25

    致谢... 26

    参考文献... 26


     

     

    一、 蒙特卡洛方法和Gibbs 采样

    深度置信网络,是由多层限制波尔兹曼机组成,在网络学习过程中用到了蒙特卡洛方法,所以在学习深度置信网络的过程中,首先需要了解蒙特卡洛方法的作用、原理、使用方法。

    1.1 随机模拟(蒙特卡罗方法)的作用

    随机模拟(或者统计模拟)方法的别名是蒙特卡罗方法(Monte CarloSimulation)。现代的统计模拟方法最早由数学家乌拉姆提出,被命名为蒙特卡罗方法,蒙特卡罗是著名的赌场,赌博总是和统计密切关联的,所以这个命名风趣而贴切,很快被大家广泛接受。

    统计模拟中有一个重要的问题就是给定一个概率分布p(x),我们如何在计算机中生成它的样本。可是,这些样本有什么用呢?举个例子,假设在一场射击比赛中,经过了多轮射击,最后要计算运动员的平均成绩。假如运动员射击了无数次,我们可以得到运动员射击点的分布函数 , 表示射击点与靶心的距离, 表示射击点在 处时的成绩,那么该运动员的平均成绩便可以通过下面的一个积分求得:

    但显然,上述的 是很难求得的,因此在实际中,假设运动员射击了 次,我们可以将多次的成绩相加,然后平均来近似地表示成绩,即

    要强调一点,利用蒙特卡洛思想的条件是,假设我们以及知道了概率 ,而且我们也已经得到了大量服从概率分布 的样本,再此基础上我们才能通过抽样来求解上面的积分。但这也造成了蒙特卡洛方法的一个缺陷,即有时候,我们虽然知道概率 ,但上述 太复杂,我们得不到,服从这一分布的样本我们也没有现成的,此时要使用蒙特卡洛方法,就要创造一批服从分布 随机样本,那应该怎么创造呢?

    一般而言均匀分布Uniform(0,1)的样本是相对容易生成的。 通过线性同余发生器可以生成伪随机数,我们用确定性算法生成[0,1]之间的伪随机数序列后,这些序列的各种统计指标和均匀分布Uniform(0,1)的理论计算结果非常接近。这样的伪随机序列就有比较好的统计性质,可以被当成真实的随机数使用。

    而我们常见的概率分布,无论是连续的还是离散的分布,都可以基于Uniform(0,1)的样本生成。例如正态分布可以通过著名的Box-Muller变换得到

    如果随机变量 独立且 服从分布Uniform[0,1],

    独立且服从标准正态分布。其它几个著名的连续分布,包括指数分布、Gamma分布、t分布、F分布、Beta分布、Dirichlet分布等等,也都可以通过类似的数学变换得到;离散的分布通过均匀分布更加容易生成。更多的统计分布如何通过均匀分布的变换生成出来,大家可以参考统计计算的书,其中SheldonM.Ross的《统计模拟》是写得非常通俗易懂的一本。

    不过我们并不是总是这么幸运的,当p(x)的形式很复杂,或者p(x)是个高维的分布的时候,样本的生成就可能很困难了。譬如有如下的情况

    §  ,而 我们是可以计算的,但是底下的积分式无法计算。

    § p(xy)是一个二维的分布函数,这个函数本身计算很困难,但是条件分布p(x|y),p(y|x)的计算相对简单;如果p(x)是高维的,这种情形就更加明显。

     

    此时就需要使用一些更加复杂的随机模拟的方法来生成样本。而本节中将要重点介绍的MCMC(Markov Chain MonteCarlo)和Gibbs Sampling算法就是最常用的一种,这两个方法在现代贝叶斯分析中被广泛使用。要了解这两个算法,我们首先要对马氏链的平稳分布的性质有基本的认识。

    3.2蒙特卡洛的基础——马氏链及其平稳分布

    马氏链的数学定义很简单:

    也就是状态转移的概率只依赖于前一个状态。

    我们先来看马氏链的一个具体的例子。社会学家经常把人按其经济状况分成3类:下层(lower-class)、中层 (middle-class)、上层 (upper-class),我们用1、2、3分别代表这三个阶层。社会学家们发现决定一个人的收入阶层的最重要的因素就是其父母的收入阶层。如果一个人的收入属于下层类别,那么他的孩子属于下层收入的概率是0.65,属于中层收入的概率是0.28,属于上层收入的概率是0.07。事实上,从父代到子代,收入阶层的变化的转移概率如下

     

    使用矩阵的表示方式,转移概率矩阵记为

    假设当前这一代人处在下层、中层、上层的人的比例是概率分布向量π0=[π0(1),π0(2),π0(3)],那么他们的子女的分布比例将是π1=π0P,他们的孙子代的分布比例将是π2=π1P=π0P2,……,第n代子孙的收入分布比例将是πn=πn−1P=π0Pn

    假设初始概率分布为π0=[0.21,0.68,0.11],则我们可以计算前n代人的分布状况如下

    我们发现从第7代人开始,这个分布就稳定不变了,这个是偶然的吗?我们换一个初始概率分布π0=[0.75,0.15,0.1]试试看,继续计算前n代人的分布状况如下

    我们发现,到第9代人的时候,分布又收敛了。最为奇特的是,两次给定不同的初始概率分布,最终都收敛到概率分布π=[0.286,0.489,0.225],也就是说收敛的行为和初始概率分布π0无关。这说明这个收敛行为主要是由概率转移矩阵P决定的。我们计算一下Pn

    我们发现,当n足够大的时候,这个Pn矩阵的每一行都是稳定地收敛到π=[0.286,0.489,0.225]这个概率分布。自然的,这个收敛现象是绝大多数马氏链的共同行为,关于马氏链的收敛我们有如下漂亮的定理:

    马氏链定理:如果一个非周期马氏链具有转移概率矩阵P,且它的任何两个状态是连通的,经过足够多次的转移,状态j的概率是一定的,且与初始状态i无关,记 请注意,这里的π指的是一种分布。此外我们有下面的推论

    a)  

    b)  

    c)   是方程 的唯一非负解,其中, 称为马氏链的平稳分布。

    这个马氏链的收敛定理非常重要,所有的MCMC (Markov Chain MonteCarlo)方法都是以这个定理作为理论基础的。定理的证明相对复杂,一般的随机过程课本中也不给证明,所以我们就不用纠结它的证明了,直接用这个定理的结论就好了。我们对这个定理的内容做一些解释说明:

    a)       该定理中马氏链的状态不要求有限,可以是有无穷多个的;

    b)       两个状态ij是连通并非指i可以直接一步转移到j (Pij>0),而是指i可以通过有限的n步转移到达j (Pijn>0)。

    c)   我们用Xi表示在马氏链上跳转第i步后所处的状态,如果 存在,很容易证明以上定理的第二个结论。由于

    上式两边取极限就得到

    从初始概率分布π0出发,我们在马氏链上做状态转移,记马氏链上跳转第i步后的状态Xi的概率分布为πi,则有

    由马氏链收敛的定理,概率分布πi(x)将收敛到平稳分布π(x)。假设到第n步的时候马氏链收敛,则有

     

    所以XnXn+1Xn+2,⋯∼π(x)都是同分布的随机变量,当然他们并不独立。如果我们从一个具体的初始状态x0开始,沿着马氏链按照概率转移矩阵做跳转,那么我们得到一个转移序列x0x1x2,⋯xnxn+1⋯,由于马氏链的收敛行为,xnxn+1,⋯都将是平稳分布π(x)的样本

    3.3 举个例子——蒙特卡洛方法的使用步骤

    对于给定的概率分布p(x),我们希望能有便捷的方式生成它对应的样本。由于马氏链能收敛到平稳分布,于是一个很的漂亮想法是:如果我们能构造一个转移矩阵为P的马氏链,使得该马氏链的平稳分布恰好是p(x),那么我们从任何一个初始状态x0出发沿着马氏链转移,得到一个转移序列x0,x1,x2,⋯xn,xn+1,…如果马氏链在第n步已经收敛了,于是我们就得到了π(x)的样本xn,xn+1⋯。

    这个绝妙的想法在1953年被Metropolis想到了,为了研究粒子系统的平稳性质,Metropolis考虑了物理学中常见的波尔兹曼分布的采样问题,首次提出了基于马氏链的蒙特卡罗方法,即Metropolis算法,并在最早的计算机上编程实现。Metropolis算法是首个普适的采样方法,并启发了一系列MCMC方法,所以人们把它视为随机模拟技术腾飞的起点。Metropolis的这篇论文被收录在《统计学中的重大突破》中,Metropolis算法也被遴选为二十世纪的十个最重要的算法之一。

    我们接下来介绍的MCMC算法是Metropolis算法的一个改进变种,即常用的Metropolis-Hastings算法。由上一节的例子和定理我们看到了,马氏链的收敛性质主要由转移矩阵P决定,所以基于蒙特卡洛方法做采样的关键问题是如何构造转移矩阵P,使得平稳分布恰好是我们要的分布p(x)。如何能做到这一点呢?我们主要使用如下的定理。

    定理:[细致平稳条件]如果马氏链的转移矩阵P和分布π(x)满足

    π(x)是马氏链的平稳分布,上式被称为细致平稳条件(detailed balance condition)。其实这个定理是显而易见的,因为细致平稳条件的物理含义就是对于任何两个状态ij,从i转移出去到j而丢失的概率质量,恰好会被从j转移回i的概率质量补充回来,所以状态i上的概率质量π(i)是稳定的,从而π(x)是马氏链的平稳分布。数学上的证明也很简单,由细致平稳条件可得

    由于π是方程πP=π的解,所以π是平稳分布。

    假设我们已经有一个转移矩阵为Q马氏链(Q是随意取的),其中 表示从状态i转移到状态j的概率,显然,通常情况下,细致平稳条件是不成立的,即

    所以p(x)不太可能是这个马氏链的平稳分布。那么,我们可否对马氏链作一个改造,使得细致平稳条件成立呢?譬如,我们引入一个 ,我们希望

    但是,取什么样的 和 可以使得以上等式能成立呢?最简单的,按照对称性,我们可以取

    于是细致平稳条件就成立了。所以有

    于是我们把原来具有转移矩阵Q的一个很普通的马氏链,改造为了具有转移矩阵Q′的马氏链,而且Q′的平稳分布就是p(x)!

    在改造Q的过程中引入的 和 称为接受概率,物理意义可以理解为在原来的马氏链上,从状态i 的概率转跳转到状态j的时候,我们以 的概率接受这个转移,于是得到新的马氏链 的转移概率为 。

    把以上的过程整理一下,假设我们已经有一个转移矩阵Q(对应元素为 ),我们就得到了如下的用于采样概率分布p(x)的算法。

    上述过程中p(x),q(x|y)说的都是离散的情形,事实上即便这两个分布是连续的,以上算法仍然是有效,于是就得到更一般的连续概率分布p(x)的采样算法,而q(x|y)就是任意一个连续二元概率分布对应的条件分布。

     

    以上的MCMC采样算法已经能很漂亮的工作了,不过它有一个小的问题:马氏链Q在转移的过程中的接受率 可能偏小,这样采样过程中马氏链容易原地踏步,这使得马氏链遍历所有的状态空间要花费太长的时间,收敛到平稳分布p(x)的速度太慢。有没有办法提升一些接受率呢?

    假设 、 ,假设此时满足细致平稳条件,于是

    上式两边扩大5倍,我们改写为

    看,我们提高了接受率,而细致平稳条件并没有打破!这启发我们可以把细致平稳条件的 和 同比例放大,使得两数中最大的一个放大到1,这样我们就提高了采样中的跳转接受率。所以我们可以取

    于是,经过对上述MCMC采样算法中接受率的微小改造,我们就得到了如下教科书中最常见的Metropolis-Hastings算法。

     

    3.4 Gibbs 采样

    对于高维的情形,由于接受率α的存在(通常α<1),以上Metropolis-Hastings算法的效率不够高。能否找到一个转移矩阵Q使得接受率α=1呢?我们先看看二维的情形,假设有一个概率分布 ,考察x坐标相同的两个点A(x1,y1)、B(x1,y2),我们发现

    所以得到

    基于以上等式,我们发现,在x=x1这条平行于y轴的直线上,如果使用条件分布p(y|x1)做为任何两个点之间的转移概率,那么任何两个点之间的转移满足细致平稳条件。同样的,如果我们在y=y1这条直线上任意取两个点A(x1,y1),C(x2,y1),也有如下等式

    因此,对于二维变量,我们可以如下构造平面上任意两点之间的转移概率矩阵Q

    于是

     如果

     如果

    其它

    有了如上的转移矩阵Q,我们很容易验证对平面上任意两点X,Y,满足细致平稳条件

    于是这个二维空间上的马氏链将收敛到平稳分布 。而这个算法就称为Gibbs Sampling算法,是Stuart Geman和Donald Geman这两兄弟于1984年提出来的,之所以叫做Gibbs Sampling是因为他们研究了Gibbs random field,这个算法在现代贝叶斯分析中占据重要位置。

     

     

    以上采样过程中,如图所示,马氏链的转移只是轮换的沿着坐标轴x轴和y轴做转移,于是得到样本(x0,y0),(x0,y1),(x1,y1),(x1,y2),(x2,y2),⋯马氏链收敛后,最终得到的样本就是p(x,y)的样本,而收敛之前的阶段称为burn-in period。额外说明一下,我们看到教科书上的Gibbs Sampling算法大都是坐标轴轮换采样的,但是这其实是不强制要求的。最一般的情形可以是,在t时刻,可以在x轴和y轴之间随机的选一个坐标轴,然后按条件概率做转移,马氏链也是一样收敛的。轮换两个坐标轴只是一种方便的形式。

    以上的过程我们很容易推广到高维的情形,如果x1变为多维情形x1,可以看出推导过程不变,所以细致平稳条件同样是成立的

    此时转移矩阵Q由条件分布p(y|x1)定义。上式只是说明了一根坐标轴的情形,和二维情形类似,很容易验证对所有坐标轴都有类似的结论。所以n维空间中对于概率分布 可以如下定义转移矩阵

    a)     如果当前状态为 ,马氏链转移的过程中,只能沿着坐标轴做转移。沿着xi这根坐标轴转移的时候,转移概率由条件概率p(xi|x1,⋯,xi−1,xi+1,⋯,xn)定义;

    b)       其它无法沿着单根坐标轴进行的跳转,转移概率都设置为0。

    c)       于是我们可以把Gibbs Smapling算法从采样二维的p(x,y)推广到采样n维的p(x1,x2,⋯,xn)

    以上算法收敛后,得到的就是概率分布p(x1,x2,⋯,xn)的样本,当然这些样本并不独立,但是我们此处要求的是采样得到的样本符合给定的概率分布,并不要求独立。同样的,在以上算法中,坐标轴轮换采样不是必须的,可以在坐标轴轮换中引入随机性,这时候转移矩阵Q中任何两个点的转移概率中就会包含坐标轴选择的概率,而在通常的Gibbs Sampling算法中,坐标轴轮换是一个确定性的过程,也就是在给定时刻t,在一根固定的坐标轴上转移的概率是1。


     

    二.限制波尔兹曼机

    2.1限制波尔兹曼机(RBM)

    2.1.1 RBM的使用说明

    一个RBM的结构如下:

    以上的RBM网络结构有m个可视节点和n个隐藏节点,其中每个可视节点只和n个隐藏节点相关,和其他可视节点是独立的,即这个可视节点的状态只受n个隐藏节点的影响;类似的,每个隐藏节点只受m个可视节点的影响,这个特点使得RBM的训练变得容易了。

    RBM网络有几个参数,一个是可视层与隐藏层之间的权重矩阵 ,一个是可视节点的偏移量 ,一个是隐藏节点的偏移量 ,这几个参数决定了RBM网络将一个m维的样本编码成一个什么样的n维的样本。

    RBM网络的功能有下面的几种,就简单地先描述一下。

    首先为了描述容易,先假设每个节点取值都在集合 中,即 。

    假如一个训练样本 的取值为 ,经过RBM网络,可以得到这一样本的n维编码, ,这n维的编码也可以认为是抽取了n个特征的样本。而这个n维的编码后的样本是按照下面的规则生成的:对于给定的隐藏层的第i个节点的取值为1的概率为

    其中的v取值就是x,hi的取值就是yi,其中 ,是sigmoid函数。也就是说,编码后的样本y的第i个位置的取值为1的概率是 。所以,生成yi的过程就是:

    1)先利用公式 ,根据x的值计算概率 ,其中vj的取值就是xj的值。

    2)然后产生一个0到1之间的随机数,如果它小于 ,yi的取值就是1,否则就是0(假如p(hi=1|v)=0.6,这里就是因为yi的取值就是1的概率是0.6,而这个随机数小于0.6的概率也是0.6;如果这个随机数小于0.6,就是这个事件发生了,那就可以认为yi的取值是1这个事件发生了,所以把yi取值为1)。上述步骤相当于得到了符合概率分布为 的一个样本,这样的采样方法称为Gibbs采样。

    反过来,现在知道了一个编码后的样本y,想要知道原来的样本x,即解码过程,跟上面也是同理,过程如下:

    3)先利用公式 ,根据y的值计算概率 ,其中hi的取值就是yi的值。

    4)然后产生一个0到1之间的随机数,如果它小于 ,vj的取值就是1,否则就是0。

    对于2)的说明:例如,你现在出去逛街,走到一个岔路口,你只想随便逛逛,所以你是有0.5的概率往左边的路,0.5的概率往右边的路;但是你不知道怎么选择哪个路,所以你选择了抛硬币,正面朝上你就向左,反面朝上就向右。现在你只抛一次,如果是正面朝上,就向左走。回到上面的问题,假如某节点A取值为1的概率是0.6,现在要给节点A取值,就拿这个硬币抛一下,正面朝上就取值1,反面朝上就取值0,这个就相当于抛硬币决定走哪个路的那个过程。现在假如找不到这样的不均匀的硬币,就拿随机数生成器来代替(生成的数是0-1之间的浮点数);因为随机数生成器取值小于0.6的概率也是0.6,大于0.6的概率是0.4。

    这里一定要记住 指的是通过隐藏节点所恢复的第i个可视节点的状态,不是输入xi

    2.1.2 RBM的用途

    RBM的用途主要是两种,一是对数据进行编码,把RBM作为一个降维的方法来使用,然后交给监督学习方法去进行分类或回归;二是得到了权重矩阵和偏移量,供BP神经网络初始化训练。其中的原因是神经网络也要训练一个权重矩阵和偏移量,但如果直接用BP神经网络,初始值选得不好的话,往往会陷入局部极小值。实际应用结果表明,直接把RBM训练得到的权重矩阵和偏移量作为BP神经网络初始值,得到的结果会非常地好

    这就类似爬山,如果一个风景点里面有很多个山峰,如果让你随便选个山就爬,希望你能爬上最高那个山的山顶,但是你的精力是有限的,只能爬一座山,而你也不知道哪座山最高,这样,你就很容易爬到一座不是最高的山上。但是,如果用直升机把你送到最高的那个山上的靠近山顶处,那你就能很容易地爬上最高的那座山。这个时候,RBM就的角色就是那个直升机。

    强调一点,在深度置信网络里,多个RBM串联在一起,利用的就是RBM的编码能力。例如,输入是一个向量化的28*28的图像,我们希望输入的信息转化为隐藏层节点,然后再转化为可视层后,此时的可视层和输入的值尽量一致。如果输入服从某一种分布的话,我们无监督训练的目的就是学习最合适的参数wbc,使得由这些参数表示出的可视层节点分布与输入样本的分布尽可能一致。

    庆幸的是,利用下文的能量模型,我们发现通过隐藏层恢复的可视层节点服从Gibbs分布,但是里面的参数wbc是未知的,我们希望的就是学习到这些参数。

    2.2限制波尔兹曼机(RBM)能量模型

    2.2.1 能量模型定义

    介绍RBM之前,首先需要了解能量模型。能量模型是个什么样的东西呢?直观上的理解就是,把一个表面粗糙又不太圆的小球,放到一个表面也比较粗糙的碗里,就随便往里面一扔,看看小球停在碗的哪个地方。一般来说停在碗底的可能性比较大,停在靠近碗底的其他地方也可能,甚至运气好还会停在碗口附近(这个碗是比较浅的一个碗);能量模型把小球停在哪个地方定义为一种状态,每种状态都对应着一个能量,这个能量由能量函数来定义,小球处在某种状态的概率(如停在碗底的概率跟停在碗口的概率当然不一样)可以通过这种状态下小球具有的能量来定义(换个说法,如小球停在了碗口附近,这是一种状态,这个状态对应着一个能量E,而发生“小球停在碗口附近”这种状态的概率p,可以用E来表示,表示成p=f(E),其中f是能量函数),这就是我认为的能量模型。

    这样,就有了能量函数,概率之类的东西。波尔兹曼网络是一种随机网络。描述一个随机网络,总结起来主要有两点。

    第一,概率分布函数。由于网络节点的取值状态是随机的,从贝叶斯网的观点来看,要描述整个网络,需要用三种概率分布来描述系统。即联合概率分布,边缘概率分布和条件概率分布。要搞清楚这三种不同的概率分布,是理解随机网络的关键,这里向大家推荐的书籍是张连文所著的《贝叶斯网引论》。很多文献上说受限波尔兹曼是一个无向图,从贝叶斯网的观点看,受限波尔兹曼网络也可以看作一个双向的有向图,即从输入层节点可以计算隐层节点取某一种状态值的概率,反之亦然。

    第二,能量函数。随机神经网络是根植于统计力学的。受统计力学中能量泛函的启发,引入了能量函数。能量函数是描述整个系统状态的一种测度。系统越有序或者概率分布越集中,系统的能量越小。反之,系统越无序或者概率分布越趋于均匀分布,则系统的能量越大。能量函数的最小值,对应于系统的最稳定状态。

     

    2.2.2 能量模型作用

    为什么要弄这个能量模型呢?原因有几个。

    第一、RBM网络是一种无监督学习的方法,无监督学习的目的是最大可能的拟合输入数据,所以学习RBM网络的目的是让RBM网络最大可能地拟合输入数据。

    第二、对于一组输入数据来说,现在还不知道它符合什么分布,学习起来是非常困难的。例如,知道它符合高斯分布,那就可以写出似然函数,然后求解,就能求出这是一个什么样的高斯分布;但如果不知道它符合一个什么分布,那可是连似然函数都没法写的,根本就无从下手。好在天无绝人之路——统计力学的结论表明,任何概率分布都可以转变成基于能量的模型,而且很多的分布都可以利用能量模型的特有的性质和学习过程,有些甚至从能量模型中找到了通用的学习方法。有这样一个好东西,当然要用了。

    第三、在马尔科夫随机场(MRF)中能量模型主要扮演着两个作用:一、全局解的度量(目标函数);二、能量最小时的解(各种变量对应的配置)为目标解。也就是能量模型能为无监督学习方法提供两个东西:a)目标函数;b)目标解。换句话说,就是——使用能量模型使得学习一个数据的分布变得容易可行了。

    能否把最优解嵌入到能量函数中至关重要,决定着我们具体问题求解的好坏。统计模式识别主要工作之一就是捕获变量之间的相关性,同样能量模型也要捕获变量之间的相关性,变量之间的相关程度决定了能量的高低。把变量的相关关系用图表示出来,并引入概率测度方式就构成了概率图模型的能量模型。

    RBM作为一种概率图模型,引入了概率就可以使用采样技术求解,在CD(contrastivedivergence)算法中采样部分扮演着模拟求解梯度的角色。

    能量模型需要一个定义能量函数,RBM的能量函数的定义如下

    这个能量函数的意思就是,每个可视节点和隐藏节点之间的连接结构都有一个能量,通俗来说就是可视节点的每一组取值和隐藏节点的每一组取值都有一个能量,如果可视节点的一组取值(也就是一个训练样本的值)为(1,0,1,0,1,0),隐藏节点的一组取值(也就是这个训练样本编码后的值)为(1,0,1),然后分别代入上面的公式,就能得到这个连接结构之间的能量。

    能量函数的意义是有一个解释的,叫做专家乘积系统(POE,product of expert),这个理论也是hinton发明的,他把每个隐藏节点看作一个“专家”,每个“专家”都能对可视节点的状态分布产生影响,可能单个“专家”对可视节点的状态分布不够强,但是所有的“专家”的观察结果连乘起来就够强了。具体我也看不太懂,各位有兴趣看hinton的论文吧,中文的也有,叫《专家乘积系统的原理及应用,孙征,李宁》。

    另外的一个问题是:为什么要搞概率呢?下面就是解释。能量模型需要两个东西,一个是能量函数,另一个是概率,有了概率才能跟要求解的问题联合起来。下面就介绍从能量模型到概率。

     

    2.3从能量模型到概率

    2.3.1 从能量函数到概率

    为了引入概率,需要定义概率分布。根据能量模型,有了能量函数,就可以定义一个可视节点和隐藏节点的联合概率

    也就是一个可视节点的一组取值(一个状态)和一个隐藏节点的一组取值(一个状态)发生的概率 是由能量函数来定义的。这个概率不是随便定义的,而是有统计热力学的解释的——在统计热力学上,当系统和它周围的环境处于热平衡时,一个基本的结果是状态 发生的概率如下面的公式

    其中 表示系统在状态i时的能量,T为开尔文绝对温度, 为Boltzmann常数,Z为与状态无关的常数,用来归一化。

    我们这里的 变成了 ,因为 也是一个状态,其他的参数T和 由于跟求解无关,就都设置为1了,Z就是我们上面联合概率分布的分母,这个分母是为了让我们的概率的和为1,这样才能保证 是一个概率。

    现在我们得到了一个概率,其实也得到了一个分布,其实这个分布还有一个好听点的名字,可以叫做Gibbs分布,当然不是一个标准的Gibbs分布,而是一个特殊的Gibbs分布,这个分布是有一组参数的,就是能量函数的那几个参数wbc

    有了这个联合概率,就可以得到一些条件概率,是用积分去掉一些不想要的量得到的。

    2.3.2 从概率到极大似然

    上面得到了一个样本和其对应编码的联合概率,也就是得到了RBM网络的Gibbs分布的概率密度函数。现在回到求解的目标——RBM网络表示的Gibbs分布与输入样本的分布尽可能地接近。

    假设 表示样本空间,q是输入样本的分布,即q(x)表示训练样本x的概率, q其实就是要拟合的那个样本表示分布的概率;再假设pRBM网络表示的Gibbs分布的边缘分布(只跟可视节点有关,隐藏节点是通过积分去掉了,可以理解为可视节点的各个状态的分布),输入样本的集合是S,那现在就可以定义样本表示的分布和RBM网络表示的边缘分布的KL距离

    如果输入样本表示的分布与RBM表示的Gibbs分布完全符合,这个KL距离就是0,否则就是一个大于0的数。第一项其实就是输入样本的熵(熵的定义),输入样本定了熵就定了;第二项没法直接求,但是,偷懒一下,可以用蒙特卡罗抽样(后面有章节会详细介绍)来估算这个值。直接把输入样本当作利用抽样过程抽中的样本(输入样本肯定符合分布q(x)),第二项可以用 来估计,其中的l表示训练样本个数

    由于KL的值肯定是大于等于0的,所以第一项肯定大于等于第二项,让第二项取得最大值,就能让KL距离最小;最后,还可以发现,最大化 ,相当于最大化 ,而这就是极大似然估计。结论就是求解输入样本的极大似然,就能让RBM网络表示的Gibbs分布和样本本身表示的分布最接近。这就是为什么RBM问题最终可以转化为极大似然来求解。

     

    2.4求解极大似然

    既然是求解极大似然,就要对似然函数求最大值,求解的过程就是对参数就导,然后用梯度上升法不断地把目标函数提升,最终到达停机条件(在这里看不懂的同学就去看参考文献中的《从极大似然到EM》)

    设参数为 (注意是一组参数),则似然函数可以写为

    为了省事 写成p(v)了,然后就可以对它的对数进行求导了(因为直接求一个连乘的导数太复杂,所以变成对数来求)

    可以看到,是对每个p(v)求导后再加和,然后就有了下面的推导了。

    到了这一步的时候,我们又可以发现问题了。我们可以看到的是,对每一个样本,第二个等号后面的两项其实都像是在求一个期望,第一项求的是 这个函数在概率p(h|v)下的期望,第二项求的是 这个函数在概率p(v,h)下面的期望。

    上面的两个部分其实就是两个积分,因此我们可以尝试利用蒙特卡洛的方法求解上面的积分。回顾上面关于蒙特卡洛方法的介绍,求解上面式子的第一项时,根据蒙特卡洛的思路,首先我们要有大量符合分布p(h|v)的样本,而我们根据能量函数已经知道了条件概率:

    根据蒙特卡洛方法的步骤,每一次输入 都是一个样本,我们都可以得到概率 ,然后产生一个随机数,如果随机数大于 , 的样本取1,否则样本取0,这样我们就得到了此时h的一个样本。而对于一个样本 ,它的 也是可以计算的,只求多个输入下的均值就可以估算出第一项。

    但是第二项求解起来就比较复杂。因为我们没有RBM网络表示的Gibbs分布下的样本的(后面会介绍这些怎么抽)。

    为了进行下面的讨论,把这个梯度再进一步化简,看看能得到什么。根据能量函数的公式,是有三个参数的w,b和c,就分别对这三个参数求导

    其中第四个等号的原因是 ,第三个等号的原因是 。

    到了这一步,我们来分析一下,从上面的联合概率那一堆,我们可以得到下面的

     

     

     

    也就是说 是可以求的。剩下的麻烦全部集中在第二项了。第二项就是上面的导数化简后的减号后面的那一项。要求第二项,就要遍历所有可能的v的值,然后根据公式去计算几个梯度的值,那样够麻烦的了,还好蒙特卡罗给出了一个偷懒的方法。把上面的式子再写出来:

     

    上式是RBM的核心,需要好好理解。首先,这里的 中的 指的通过隐藏层节点恢复出来可视层节点,而不是输入时候的可视层, 也就表示的是这些恢复出来的可视层节点服从的分布。之前的关于能量函数的讨论中已经提到, 其实就是参数为wacGibbs分布,是已知的。要想利用蒙特卡洛方法求解上式,最关键的是取得服从分布为 的样本。

    对于上面的情况,是这么处理的,对每个训练样本x,都用某种抽样方法抽取一个它对应的符合RBM网络表示的Gibbs分布(恢复的可视节点v的分布)的样本,假如叫y;那么,对于整个的训练集{x1,x2,…xl}来说,就得到了一组符合RBM网络表示的Gibbs分布的样本{y1,y2,…,yl},然后拿这组样本去估算第二项,那么梯度就可以用下面的公式来近似了

    其中xk表示第k个训练样本,yk表示第k个训练样本对应的RBM网络表示的Gibbs分布(不妨将这个分布称为R)的样本(yk是根据分布R抽取的样本,而且这个样本是从xk出发,用Gibbs抽样抽取出来的,也就是说yk服从分布R,可以用来估算第二项,同时yk跟xk有关),Vyk表示可视节点取值为yk的时候的状态,那么Vykj就表示yk的第j个特征的取值。

    这样,梯度出来了,这个极大似然问题可以解了,最终经过若干论迭代,就能得到那几个参数w,b,c的解。

     

    2.5简单的抽样算法——CD-k

    上面提到的“某种抽样方法”,现在一般就用Gibbs抽样,然后hinton教授还根据这个弄出了一个CD-k算法,就是用来解决RBM的抽样的。下面一章就介绍这个吧。

    Gibbs抽样一般要进行k步的抽样,这个k一般还要比较大,所以是比较费时间的,尤其是在训练样本的特征数比较多(可视节点数大)的时候,所以hinton教授就弄一个简化的版本,叫做ContrastiveDivergence(CD),也就对比散度。与Gibbs抽样不同,hinton教授指出当使用训练样本初始化v0的时候,仅需要较少的抽样步数(一般就一步)就可以得到足够好的近似了。

    在CD算法一开始,可见单元的状态就被设置为一个训练样本,并用上面的几个条件概率 来对隐藏节点的每个单元都从{0,1}中抽取到相应的值,然后再利用 来对可视节点的每个单元都从{0,1}中抽取相应的值,这样就得到了v1了,一般v1就够了,就可以拿来估算梯度了。

    下面给出RBM的基于CD-k的快速学习的主要步骤。

     

     

    参考文献

    [1] http://blog.csdn.net/mytestmy/article/details/9150213/,深度学习读书笔记之RBM(限制波尔兹曼机)

    [2] http://www.52nlp.cn/lda-math-mcmc-%E5%92%8C-gibbs-sampling1 gibbs抽样相关

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 深度置信网络(Deep Belief Nets,DBN)的核心组件为受限玻尔兹曼机(Restricted Boltzmann Machine,RBM),RBM的训练传统采用对比散度准则(Contrastive Divergence,CD),但CD是对数似然梯度有偏差的近似。...
  • 基于局部二值模式与深度置信网络的人脸识别.pdf
  • 提出一种基于卷积深度置信网络(CDBN)实现配电网故障分类的方法,利用离散小波包变换(DWPT)分解主变低压侧进线电流和母线电压等电量信号并构造时频矩阵,将时频矩阵转换成时频谱图的像素矩阵后作为CDBN的输入,经CDBN...
  • 研究提出了一种基于区分深度置信网络的枸杞病害图像分类识别模型。首先,把枸杞叶部病害图像通过自动裁剪方式获得包含典型病斑的子图像,再采用复杂背景下的图像分割方法分割病斑区域,提取病斑图像的颜色特征、纹理...
  • 针对因线路分布复杂、终端数目庞大等带来的低压台区理论线损计算困难的问题,提出一种基于深度置信网络(DBN)的低压台区理论线损计算新方法。在训练过程中,先利用贪婪算法对DBN模型中的神经网络层进行逐层无监督的预...
  • 介绍深度置信网络(DBN)理论基础的发展,对比分析深层结构DBN与浅层网络结构的差异,最后引用多篇文献分析研究DBN在文字检测、人脸及表情识别领域和遥感图像领域的应用效果。全面介绍了深度学习模型DBN,深入分析...
  • 深度置信网络的一个应用

    千次阅读 2018-07-25 23:32:54
    推荐系统是一个用传统方法比较难做好,但是用深度置信网络可以极大地减少计算量,达到比较好的效果的一个案例。 传统推荐系统算法: 1、构造用户-评分矩阵,对矩阵进行SVD分解。 2、用深度置信网络。 受限...
  • 深度置信网络(Deep Belief Networks)DBN 一、DBN算法的功能 深度置信网络(Deep Belief Networks)DBN算法是机器学习之神经网络的一种,既可以用于非监督学习,也可以用于监督学习。DBN是一个概率生成模型,与传统...
  • 受限玻尔兹曼机和深度置信网络

    千次阅读 2018-06-27 21:17:24
    受限玻尔兹曼机和深度置信网络 引言 梯度弥散一直是困扰着深度神经网络的发展,那么如何解决梯度弥散问题呢?多伦多大学的Geoff Hinton提出了设想:受限玻尔兹曼机(Restricted Boltzmann Machines, RBM),即...
  • 深度置信网络DBN

    2018-08-17 21:09:58
    DBN实例,运行与matlab版本有关系,注释详细,建议用2014版
  • 深度置信网络(Deep Belief Networks)DBN

    万次阅读 多人点赞 2018-09-12 20:33:59
    深度置信网络(Deep Belief Networks)DBN算法是机器学习之神经网络的一种,既可以用于非监督学习,也可以用于监督学习。DBN是一个概率生成模型,与传统的判别模型的神经网络相对,生成模型是建立一个观察数据和...
  • 深度置信网络(DBN)   RBM的作用就是用来生成似然分布的互补先验分布,使得其后验分布具有因子形式。   因此,DBN算法解决了Wake-Sleep算法表示分布难以匹配生成分布的难题,通过RBM使得训练数据的生成分布具有...
  • 针对现有交通流预测方法忽视对交通流数据自身特征的有效利用以及不能模拟更复杂的数学运算,提出了一种改进深度置信网络(deep belief network,DBN)的交通流预测方法。该方法结合深度置信网络模型与softmax回归...
  • 电力负荷预测是电力系统规划的重要组成部分,也是电力系统经济运行的基础,其对电力系统规划和运行都极其重要。根据历史电网负荷数据,用深度置信网络预测未来负荷大小,是很好的学习资料,特别适合刚入门人员。
  • 结合深度置信网络(DBN)在提取特征和处理高维、非线性数据等方面的优势,提出一种基于深度置信网络的故障诊断方法。该方法通过深度学习利用原始时域信号的傅里叶频谱(FFT)训练深度置信网络并完成智能诊断,其优势...
  • 上一节我们详细的讲解了受限玻尔兹曼机RBM的原理,详细阐述了该网络的快速学习原理以及算法过程,不懂受限玻尔兹曼机的建议先好好理解上一节的内容,本节主要讲解的是使用RBM组成深层神经网络的深度置信网络DBN...
  • 深度学习DBN深度置信网络

    万次阅读 热门讨论 2017-06-20 11:48:28
    深度信念网络,DBN,Deep Belief Nets,神经网络的一种。既可以用于非监督学习,类似于一个自编码机;也可以用于监督学习,作为分类器来使用。 从非监督学习来讲,其目的是尽可能地保留原始特征的特点,同时降低...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 299
精华内容 119
关键字:

深度置信网络