下载地址:DeepLearningToolBox
参考博客原文:https://blog.csdn.net/u010025211/article/details/50582693
1. DBN基础知识
DBN 是由多层 RBM 组成的一个神经网络,它既可以被看作一个生成模型,也可以当作判别模型,其训练过程是:使用非监督贪婪逐层方法去预训练获得权值。
训练过程:
- 首先充分训练第一个 RBM;
- 固定第一个 RBM 的权重和偏移量,然后使用其隐性神经元的状态,作为第二个 RBM 的输入向量;
- 充分训练第二个 RBM 后,将第二个 RBM 堆叠在第一个 RBM 的上方;
- 重复以上三个步骤任意多次;
- 如果训练集中的数据有标签,那么在顶层的 RBM 训练时,这个 RBM 的显层中除了显性神经元,还需要有代表分类标签的神经元,一起进行训练:
a) 假设顶层 RBM 的显层有 500 个显性神经元,训练数据的分类一共分成了 10 类;
b) 那么顶层 RBM 的显层有 510 个显性神经元,对每一训练训练数据,相应的标签神经元被打开设为 1,而其他的则被关闭设为 0。 - DBN 被训练好后如下图: (示意)
图 1 训练好的深度信念网络。
图中的绿色部分就是在最顶层 RBM 中参与训练的标签。注意调优 (FINE-TUNING) 过程是一个判别模型
调优过程 (Fine-Tuning) :
生成模型使用 Contrastive Wake-Sleep 算法进行调优,其算法过程是:
- 除了顶层 RBM,其他层 RBM 的权重被分成向上的认知权重和向下的生成权重;
- Wake 阶段:认知过程,通过外界的特征和向上的权重 (认知权重) 产生每一层的抽象表示 (结点状态) ,并且使用梯度下降修改层间的下行权重 (生成权重) 。也就是“如果现实跟我想象的不一样,改变我的权重使得我想象的东西就是这样的”。
- Sleep 阶段:生成过程,通过顶层表示 (醒时学得的概念) 和向下权重,生成底层的状态,同时修改层间向上的权重。也就是“如果梦中的景象不是我脑中的相应概念,改变我的认知权重使得这种景象在我看来就是这个概念”。
使用过程 :
- 使用随机隐性神经元状态值,在顶层 RBM 中进行足够多次的吉布斯抽样;
- 向下传播,得到每层的状态。
二、代码部分
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就不是问题了。