【转帖】【面向代码】学习 Deep Learning(二)Deep Belief Nets(DBNs)

今天介绍DBN的内容,其中关键部分都是(Restricted Boltzmann Machines, RBM)的步骤,所以先放一张rbm的结构,帮助理解

(图来自baidu的一个讲解ppt)

==========================================================================================

照例,我们首先来看一个完整的DBN的例子程序:

这是\tests\test_example_DBN.m 中的ex2

[cpp] view plaincopyprint?

  1. //train dbn
  2. dbn.sizes = [100 100];
  3. opts.numepochs =   1;
  4. opts.batchsize = 100;
  5. opts.momentum  =   0;
  6. opts.alpha     =   1;
  7. dbn =dbnsetup(dbn, train_x, opts);                //here!!!
  8. dbn = dbntrain(dbn, train_x, opts);                //here!!!
  9. //unfold dbn to nn
  10. nn = dbnunfoldtonn(dbn, 10);                       //here!!!
  11. nn.activation_function = ‘sigm‘;
  12. //train nn
  13. opts.numepochs =  1;
  14. opts.batchsize = 100;
  15. nn = nntrain(nn, train_x, train_y, opts);
  16. [er, bad] = nntest(nn, test_x, test_y);
  17. assert(er < 0.10, ‘Too big error‘);
//train dbn
dbn.sizes = [100 100];
opts.numepochs =   1;
opts.batchsize = 100;
opts.momentum  =   0;
opts.alpha     =   1;
dbn =dbnsetup(dbn, train_x, opts);                //here!!!
dbn = dbntrain(dbn, train_x, opts);                //here!!!

//unfold dbn to nn
nn = dbnunfoldtonn(dbn, 10);                       //here!!!
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(),dbntrain()以及dbnunfoldtonn()三个函数

最后fine tuning的时候用了(一)里看过的nntrain和nntest,参见(一)

\DBN\dbnsetup.m

这个实在没什么好说的,

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

[cpp] view plaincopyprint?

  1. for u = 1 : numel(dbn.sizes) - 1
  2. dbn.rbm{u}.alpha    = opts.alpha;
  3. dbn.rbm{u}.momentum = opts.momentum;
  4. dbn.rbm{u}.W  = zeros(dbn.sizes(u + 1), dbn.sizes(u));
  5. dbn.rbm{u}.vW = zeros(dbn.sizes(u + 1), dbn.sizes(u));
  6. dbn.rbm{u}.b  = zeros(dbn.sizes(u), 1);
  7. dbn.rbm{u}.vb = zeros(dbn.sizes(u), 1);
  8. dbn.rbm{u}.c  = zeros(dbn.sizes(u + 1), 1);
  9. dbn.rbm{u}.vc = zeros(dbn.sizes(u + 1), 1);
  10. end
    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

\DBN\dbntrain.m

应为DBN基本就是把rbm当做砖块搭建起来的,所以train也很简单

[cpp] view plaincopyprint?

  1. function dbn = dbntrain(dbn, x, opts)
  2. n = numel(dbn.rbm);
  3. //对每一层的rbm进行训练
  4. dbn.rbm{1} = rbmtrain(dbn.rbm{1}, x, opts);
  5. for i = 2 : n
  6. x = rbmup(dbn.rbm{i - 1}, x);
  7. dbn.rbm{i} = rbmtrain(dbn.rbm{i}, x, opts);
  8. end
  9. end
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了:

\DBN\rbmtrain.m

代码如下,说明都在注释里

论文参考:【1】Learning Deep Architectures for AI   以及

【2】A Practical Guide to Training Restricted Boltzmann Machines

你可以和【1】里面的这段伪代码对应一下

[cpp] view plaincopyprint?

  1. for i = 1 : opts.numepochs //迭代次数
  2. kk = randperm(m);
  3. err = 0;
  4. for l = 1 : numbatches
  5. batch = x(kk((l - 1) * opts.batchsize + 1 : l * opts.batchsize), :);
  6. v1 = batch;
  7. h1 = sigmrnd(repmat(rbm.c‘, opts.batchsize, 1) + v1 * rbm.W‘);            //gibbs sampling的过程
  8. v2 = sigmrnd(repmat(rbm.b‘, opts.batchsize, 1) + h1 * rbm.W);
  9. h2 = sigm(repmat(rbm.c‘, opts.batchsize, 1) + v2 * rbm.W‘);
  10. //Contrastive Divergence 的过程
  11. //这和《Learning Deep Architectures for AI》里面写cd-1的那段pseudo code是一样的
  12. c1 = h1‘ * v1;
  13. c2 = h2‘ * v2;
  14. //关于momentum,请参看Hinton的《A Practical Guide to Training Restricted Boltzmann Machines》
  15. //它的作用是记录下以前的更新方向,并与现在的方向结合下,跟有可能加快学习的速度
  16. rbm.vW = rbm.momentum * rbm.vW + rbm.alpha * (c1 - c2)     / opts.batchsize;
  17. rbm.vb = rbm.momentum * rbm.vb + rbm.alpha * sum(v1 - v2)‘ / opts.batchsize;
  18. rbm.vc = rbm.momentum * rbm.vc + rbm.alpha * sum(h1 - h2)‘ / opts.batchsize;
  19. //更新值
  20. rbm.W = rbm.W + rbm.vW;
  21. rbm.b = rbm.b + rbm.vb;
  22. rbm.c = rbm.c + rbm.vc;
  23. err = err + sum(sum((v1 - v2) .^ 2)) / opts.batchsize;
  24. end
  25. end
   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

\DBN\dbnunfoldtonn.m

DBN的每一层训练完成后自然还要把参数传递给一个大的NN,这就是这个函数的作用

[cpp] view plaincopyprint?

  1. function nn = dbnunfoldtonn(dbn, outputsize)
  2. %DBNUNFOLDTONN Unfolds a DBN to a NN
  3. %   outputsize是你的目标输出label,比如在MINST就是10,DBN只负责学习feature
  4. %   或者说初始化Weight,是一个unsupervised learning,最后的supervised还得靠NN
  5. if(exist(‘outputsize‘,‘var‘))
  6. size = [dbn.sizes outputsize];
  7. else
  8. size = [dbn.sizes];
  9. end
  10. nn = nnsetup(size);
  11. %把每一层展开后的Weight拿去初始化NN的Weight
  12. %注意dbn.rbm{i}.c拿去初始化了bias项的值
  13. for i = 1 : numel(dbn.rbm)
  14. nn.W{i} = [dbn.rbm{i}.c dbn.rbm{i}.W];
  15. end
  16. end
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

最后fine tuning就再训练一下NN就可以了

总结

还是那句话,本文只是梳理一下学习路线,具体的东西还是要靠paper

dbn主要的关键就是rbm,推荐几篇经典的文章吧,rbm可是Hinton的宝贝啊

其中涉及到MCMC,Contrastive divergence,感觉比Autoencoder难理解多了

[1] An Introduction to Restricted Boltzmann Machines

[2] Learning Deep Architectures for AI                                                     Bengio大作啊

[3] A Practical Guide to Training Restricted Boltzmann Machines              上面提到过,比较细致

[4] A learning Algorithm for Boltzmann Machines                                      Hinton的

时间: 2024-10-10 16:08:14

【转帖】【面向代码】学习 Deep Learning(二)Deep Belief Nets(DBNs)的相关文章

集智学院 “Deep X:Deep Learning with Deep Knowledge”的公开讲座---总结

人工智能旨在了解人类智能的本质,并创造出能模仿人类智能做出反应的智能机器,目前在一些领域已经取得显著的成功,如AI玩游戏.问答系统.自动驾驶.无人机.机器人.翻译.人脸识别.语音识别等领域.深度学习的突破性进展是人们对人工智能产生巨大兴趣的主要原因之一,它包含几个关键的技术:卷积神经网络.循环神经网络.深度强化学习.生成对抗网络.表示学习.注意力机制等. 这里举两个具体的例子.借助人工智能,我们可以使用深度学习技术进行医疗影像处理,帮助患者快速准确地诊断.目前用AI进行结核病检测已经能达到97%

【深度学习Deep Learning】资料大全

转载:http://www.cnblogs.com/charlotte77/p/5485438.html 最近在学深度学习相关的东西,在网上搜集到了一些不错的资料,现在汇总一下: Free Online Books Deep Learning66 by Yoshua Bengio, Ian Goodfellow and Aaron Courville Neural Networks and Deep Learning42 by Michael Nielsen Deep Learning27 by

机器学习(Machine Learning)&amp;amp;深度学习(Deep Learning)资料

机器学习(Machine Learning)&深度学习(Deep Learning)资料 機器學習.深度學習方面不錯的資料,轉載. 原作:https://github.com/ty4z2008/Qix/blob/master/dl.md 原作作者會不斷更新.本文更新至2014-12-21 <Brief History of Machine Learning> 介绍:这是一篇介绍机器学习历史的文章,介绍非常全面.从感知机.神经网络.决策树.SVM.Adaboost到随机森林.Deep L

Spark MLlib Deep Learning Convolution Neural Network (深度学习-卷积神经网络)3.1

3.Spark MLlib Deep Learning Convolution Neural Network (深度学习-卷积神经网络)3.1 http://blog.csdn.net/sunbow0 Spark MLlib Deep Learning工具箱,是根据现有深度学习教程<UFLDL教程>中的算法,在SparkMLlib中的实现.具体Spark MLlib Deep Learning(深度学习)目录结构: 第一章Neural Net(NN) 1.源码 2.源码解析 3.实例 第二章D

Spark MLlib Deep Learning Neural Net(深度学习-神经网络)1.1

Spark MLlib Deep Learning Neural Net(深度学习-神经网络)1.1 http://blog.csdn.net/sunbow0/ Spark MLlib Deep Learning工具箱,是根据现有深度学习教程<UFLDL教程>中的算法,在SparkMLlib中的实现.具体Spark MLlib Deep Learning(深度学习)目录结构: 第一章Neural Net(NN) 1.源码 2.源码解析 3.实例 第二章Deep Belief Nets(DBNs

Deep Learning(深度学习)学习笔记整理系列之(一)

Deep Learning(深度学习)学习笔记整理系列 [email protected] http://blog.csdn.net/zouxy09 作者:Zouxy version 1.0  2013-04-08   声明: 1)该Deep Learning的学习系列是整理自网上很大牛和机器学习专家所无私奉献的资料的.具体引用的资料请看参考文献.具体的版本声明也参考原文献. 2)本文仅供学术交流,非商用.所以每一部分具体的参考资料并没有详细对应.如果某部分不小心侵犯了大家的利益,还望海涵,并联

Deep Learning(深度学习)学习笔记整理系列 | @Get社区

body { font-family: Microsoft YaHei UI,"Microsoft YaHei", Georgia,Helvetica,Arial,sans-serif,宋体, PMingLiU,serif; font-size: 10.5pt; line-height: 1.5; } html, body { } h1 { font-size:1.5em; font-weight:bold; } h2 { font-size:1.4em; font-weight:bo

机器学习(Machine Learning)&amp;深度学习(Deep Learning)资料

机器学习(Machine Learning)&深度学习(Deep Learning)资料 <Brief History of Machine Learning> 介绍:这是一篇介绍机器学习历史的文章,介绍很全面,从感知机.神经网络.决策树.SVM.Adaboost到随机森林.Deep Learning. <Deep Learning in Neural Networks: An Overview> 介绍:这是瑞士人工智能实验室Jurgen Schmidhuber写的最新版本

机器学习(Machine Learning)&amp;深入学习(Deep Learning)资料

<Brief History of Machine Learning> 介绍:这是一篇介绍机器学习历史的文章,介绍很全面,从感知机.神经网络.决策树.SVM.Adaboost 到随机森林.Deep Learning. <Deep Learning in Neural Networks: An Overview> 介绍:这是瑞士人工智能实验室 Jurgen Schmidhuber 写的最新版本<神经网络与深度学习综述>本综述的特点是以时间排序,从 1940 年开始讲起,到