深度置信网络基础知识及程序代码

下载地址:DeepLearningToolBox
参考博客原文:https://blog.csdn.net/u010025211/article/details/50582693

1. DBN基础知识

DBN 是由多层 RBM 组成的一个神经网络,它既可以被看作一个生成模型,也可以当作判别模型,其训练过程是:使用非监督贪婪逐层方法去预训练获得权值。

训练过程:

  1. 首先充分训练第一个 RBM;
  2. 固定第一个 RBM 的权重和偏移量,然后使用其隐性神经元的状态,作为第二个 RBM 的输入向量;
  3. 充分训练第二个 RBM 后,将第二个 RBM 堆叠在第一个 RBM 的上方;
  4. 重复以上三个步骤任意多次;
  5. 如果训练集中的数据有标签,那么在顶层的 RBM 训练时,这个 RBM 的显层中除了显性神经元,还需要有代表分类标签的神经元,一起进行训练:
    a) 假设顶层 RBM 的显层有 500 个显性神经元,训练数据的分类一共分成了 10 类;
    b) 那么顶层 RBM 的显层有 510 个显性神经元,对每一训练训练数据,相应的标签神经元被打开设为 1,而其他的则被关闭设为 0。
  6. DBN 被训练好后如下图: (示意)
    在这里插入图片描述
    图 1 训练好的深度信念网络。

图中的绿色部分就是在最顶层 RBM 中参与训练的标签。注意调优 (FINE-TUNING) 过程是一个判别模型

调优过程 (Fine-Tuning) :
在这里插入图片描述
生成模型使用 Contrastive Wake-Sleep 算法进行调优,其算法过程是:

  1. 除了顶层 RBM,其他层 RBM 的权重被分成向上的认知权重和向下的生成权重;
  2. Wake 阶段:认知过程,通过外界的特征和向上的权重 (认知权重) 产生每一层的抽象表示 (结点状态) ,并且使用梯度下降修改层间的下行权重 (生成权重) 。也就是“如果现实跟我想象的不一样,改变我的权重使得我想象的东西就是这样的”。
  3. Sleep 阶段:生成过程,通过顶层表示 (醒时学得的概念) 和向下权重,生成底层的状态,同时修改层间向上的权重。也就是“如果梦中的景象不是我脑中的相应概念,改变我的认知权重使得这种景象在我看来就是这个概念”。

使用过程 :

  1. 使用随机隐性神经元状态值,在顶层 RBM 中进行足够多次的吉布斯抽样;
  2. 向下传播,得到每层的状态。

二、代码部分

test_example_DBN

%%  ex1 train a 100 hidden unit RBM and visualize its weights
rand('state',0)
dbn.sizes = [100];
opts.numepochs =   1;
opts.batchsize = 100;
opts.momentum  =   0;
opts.alpha     =   1;
dbn = dbnsetup(dbn, train_x, opts);
dbn = dbntrain(dbn, train_x, opts);
figure; visualize(dbn.rbm{1}.W');   %  Visualize the RBM weights

第一个例子是训练含有100个隐层单元的RBM,然后可视化权重。方法和之前将的训练RBM来降维是类似的。
可视化权重结果:

 %%  ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NN
    rand('state',0)
    %train dbn
    dbn.sizes = [100 100];
    opts.numepochs =   1;
    opts.batchsize = 100;
    opts.momentum  =   0;
    opts.alpha     =   1;
    dbn = dbnsetup(dbn, train_x, opts);
    dbn = dbntrain(dbn, train_x, opts);

%unfold dbn to nn
nn = dbnunfoldtonn(dbn, 10);
nn.activation_function = 'sigm';

%train nn
opts.numepochs =  1;
opts.batchsize = 100;
nn = nntrain(nn, train_x, train_y, opts);
[er, bad] = nntest(nn, test_x, test_y);
assert(er < 0.10, 'Too big error');

dbnsetup

直接分层初始化每一层的rbm(受限波尔兹曼机(Restricted Boltzmann Machines, RBM)), 同样,W,b,c是参数,vW,vb,vc是更新时用到的与momentum的变量

 for u = 1 : numel(dbn.sizes) - 1
        dbn.rbm{u}.alpha    = opts.alpha;
        dbn.rbm{u}.momentum = opts.momentum;
 
        dbn.rbm{u}.W  = zeros(dbn.sizes(u + 1), dbn.sizes(u));
        dbn.rbm{u}.vW = zeros(dbn.sizes(u + 1), dbn.sizes(u));
 
        dbn.rbm{u}.b  = zeros(dbn.sizes(u), 1);
        dbn.rbm{u}.vb = zeros(dbn.sizes(u), 1);
 
        dbn.rbm{u}.c  = zeros(dbn.sizes(u + 1), 1);
        dbn.rbm{u}.vc = zeros(dbn.sizes(u + 1), 1);
    end

dbntrain

function dbn = dbntrain(dbn, x, opts)
    n = numel(dbn.rbm);
    //对每一层的rbm进行训练
    dbn.rbm{1} = rbmtrain(dbn.rbm{1}, x, opts);
    for i = 2 : n
        x = rbmup(dbn.rbm{i - 1}, x);
        dbn.rbm{i} = rbmtrain(dbn.rbm{i}, x, opts); 
    end
end

首先映入眼帘的是对第一层进行rbmtrain(),后面每一层在train之前用了rbmup, rbmup其实就是简单的一句sigm(repmat(rbm.c’, size(x, 1), 1) + x * rbm.W’);也就是上面那张图从v到h计算一次,公式是Wx+c.

rbmtrain

   for i = 1 : opts.numepochs //迭代次数
        kk = randperm(m);
        err = 0;
        for l = 1 : numbatches
            batch = x(kk((l - 1) * opts.batchsize + 1 : l * opts.batchsize), :);
        
        v1 = batch;
        h1 = sigmrnd(repmat(rbm.c', opts.batchsize, 1) + v1 * rbm.W');            //gibbs sampling的过程
        v2 = sigmrnd(repmat(rbm.b', opts.batchsize, 1) + h1 * rbm.W);
        h2 = sigm(repmat(rbm.c', opts.batchsize, 1) + v2 * rbm.W');
        //Contrastive Divergence 的过程 
        //这和《Learning Deep Architectures for AI》里面写cd-1的那段pseudo code是一样的
        c1 = h1' * v1;
        c2 = h2' * v2;
        //关于momentum,请参看Hinton的《A Practical Guide to Training Restricted Boltzmann Machines》
        //它的作用是记录下以前的更新方向,并与现在的方向结合下,跟有可能加快学习的速度
        rbm.vW = rbm.momentum * rbm.vW + rbm.alpha * (c1 - c2)     / opts.batchsize;    
        rbm.vb = rbm.momentum * rbm.vb + rbm.alpha * sum(v1 - v2)' / opts.batchsize;
        rbm.vc = rbm.momentum * rbm.vc + rbm.alpha * sum(h1 - h2)' / opts.batchsize;
        //更新值
        rbm.W = rbm.W + rbm.vW;
        rbm.b = rbm.b + rbm.vb;
        rbm.c = rbm.c + rbm.vc;

        err = err + sum(sum((v1 - v2) .^ 2)) / opts.batchsize;
    end
end

dbnunfoldtonn

DBN的每一层训练完成后自然还要把参数传递给一个大的NN,这就是这个函数的作用.在这里DBN就相当于预训练网络,然后将训练好的参数赋给NN结构。

function nn = dbnunfoldtonn(dbn, outputsize)
%DBNUNFOLDTONN Unfolds a DBN to a NN
%   outputsize是你的目标输出label,比如在MINST就是10,DBN只负责学习feature
%   或者说初始化Weight,是一个unsupervised learning,最后的supervised还得靠NN
    if(exist('outputsize','var'))
        size = [dbn.sizes outputsize];
    else
        size = [dbn.sizes];
    end
    nn = nnsetup(size);
    %把每一层展开后的Weight拿去初始化NN的Weight
    %注意dbn.rbm{i}.c拿去初始化了bias项的值
    for i = 1 : numel(dbn.rbm)
        nn.W{i} = [dbn.rbm{i}.c dbn.rbm{i}.W];
    end
end

最后用NN来train(fine-tune)就可以了。只要理解了多层RBM,DBN就不是问题了。

  • 3
    点赞
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值