精华内容
下载资源
问答
  • 深度置信网络DBN的matlab算法实现,可直接运行,程序运行采样的数据库为MNIST手写数字数据库。
  • 详细的深度置信神经网络matlab代码,供大家学习参考
  • 神经网络基础知识讲解,包括自动编码器和深度神经网络,卷积神经网络,递归神经网络,限制波尔兹曼机和深度置信网络等和matlab代码程序
  • 详细的深度置信神经网络matlab代码。深度信念网络,DBN,Deep Belief Nets,神经网络的一种。既可以用于非监督学习,类似于一个自编码机;也可以用于监督学习,作为分类器来使用。 从非监督学习来讲,其目的是尽...
  • 转自 深度传送门【导读】推荐一份WWW 2020上的图神经网络教程。本教程的目标有两个。首先,它将概述GNN背后的理论,讨论GNN非常适合的问题类型,并介绍一些最广泛使用的GNN模型体系结构和设计用来解决的问题/应用...

    转自 深度传送门 

    【导读】推荐一份WWW 2020上的图神经网络教程。

    541826cf2e01c8132473dae7195b8365.png

    本教程的目标有两个。首先,它将概述GNN背后的理论,讨论GNN非常适合的问题类型,并介绍一些最广泛使用的GNN模型体系结构和设计用来解决的问题/应用程序。其次,它将引入深度图库(Deep Graph Library, DGL),这是一种新的软件框架,简化了高效的基于GNN的训练和推理程序的开发。为了使事情更具体,本教程将提供使用DGL的实践会话。这个实践部分将涵盖基本的图形应用程序(例如,节点分类和链接预测),以及更高级的主题,包括在大型图和分布式设置中训练GNN。此外,它还将提供使用GNNs和DGL进行实际应用(如推荐和欺诈检测)的实践教程。

    1c38c19d71e821ee7c52a02dc7d54fc3.png

    https://github.com/dglai/WWW20-Hands-on-Tutorial

    • 第1节:图神经网络概述。本节描述了图神经网络是如何运作的,它们的基本理论,以及它们相对于其他图学习方法的优势。此外,它还描述了图形上的各种学习问题,并展示了如何使用GNNs来解决这些问题。

    • 第2节:深度图库(DGL)概述。本节描述DGL提供的不同的抽象和api,这些抽象和api旨在简化GNN模型的实现,并解释DGL如何与MXNet、Pytorch和TensorFlow进行接口。然后介绍DGL的消息传递API,该API可用于开发任意复杂的GNNs和它提供的预定义GNN nn模块。

    • 第3节:基本图任务的GNN模型。本节演示如何使用GNNs解决四个关键的图数据学习任务:节点分类、链接预测、图数据分类和网络嵌入前训练。它将展示如何使用DGL的nn模块实现一个流行的GNN模型GraphSage,并展示如何在不同类型的下游任务中使用由GraphSage计算出的节点嵌入。此外,本文还将演示使用DGL的消息传递接口实现定制的GNN模型。

    • 第4节:大型图的GNN训练。本节使用第3节中描述的一些模型来演示DGL中的微型批处理训练、多GPU训练和分布式训练。它首先描述了mini-batch训练的概念如何应用于GNN,以及如何通过使用各种抽样技术来加速mini-batch计算。接下来将举例说明一种称为邻接抽样的抽样技术,如何使用木星笔记本在DGL中实现。然后将该笔记本扩展为多GPU训练和分布式训练。

    • 第5节:实际应用的GNN模型。本节使用前面几节中描述的技术,展示如何使用GNNs开发用于推荐和欺诈检测的可伸缩解决方案。在推荐方面,本文提出了一种基于最近邻的项目推荐方法,该方法通过采用端到端的学习方法,利用GNN模型学习项目嵌入。对于欺诈检测,它扩展了上一节中的节点分类模型,以处理异构图,并解决了标记样本很少的情况。

    4bc219bdcf5c1a0229bdb9d07617fcfb.png

    45e9ccaaa88e1296fff72e9732b6b8d6.png

    2c52ff9d0baaa7c43211c9a6853aa375.png

    ae8ddbb4b043065c395aa27e1dff63f4.png

    76ad397978706992668a7b19bebfeb51.png

    9ea1e36f5bd64c9563422ce9765c89a3.png

    f264b876a1f37b26d2e551635c8bebf6.png

    23b153c614e84b95c65466c509d11c61.png

    4bc43f6f68b1af34d4aa07ed4f5fbff2.png

    82c890d02e204988cb424d67507de48e.png

    f844da8231e255d4655cf3196abbdf7e.png

    f915a5dff38529593237080ae98ee9f0.png

    ffcd5ceeac597a52475957d9e4c28161.png

    24fc7ef1480ce9f2b66021af4c0b0ce4.png

    3cd5b577080353df09db274c20d26a1c.png

    0fbd22a5f8c02e03af4b4c5ec8d84af8.png

    d7a9f5e4fbb6c81c4e0af1a12547084d.png

    56e36580ffa0111a54c72c82acafb0fd.png

    54d812954aabf80c1df4bfed7dea4255.png

    f9ef4fc50f83f1844ce1c251a6bbfe1a.png

    5cea0e396e2b34f8f4719ce44a8124e6.png

    1e466e194ccb62d0f26c7a699125577c.png

    94944c48fb17c124dd23794a86274559.png

    9c6576e49ad7b1f99e5da399cb59eedc.png

    ccd3e6563c783fb04b9d097b7003c737.png

    e57f6b73bbe4d6f2a74baaa486311c67.png

    58f3afddbb79b3da8f611510b3062964.png

    fcbe54e606e86547dccebee7e3b39f9a.png

    8e63dcd9899fd37e89b376eac5e2f0b9.png

    c696328447a2a1e379529a2be6758d7d.png

    e0e1522550f652677b56402fc9696e34.png

    56544610af979302b6b6093d748ee089.png

    7b7a02de0c5ccda5178b70ad5ece0f15.png

    432b110ef7811df14a64b9543caf2406.png

    a9a6f7526162a57ac343aa035c5502a6.png

    1f1a38b10d7803e6d763eab78d21ac77.png

    b2ead27b4d03e0bf61e1f8e30e5376bc.png

    关于深度传送门

    深度传送门是一个专注于深度推荐系统与CTR预估的交流社区,传送推荐、广告以及NLP等相关领域工业界第一手的论文、资源等相关技术分享,欢迎关注!加技术交流群请添加小助手deepdeliver,备注姓名+学校/公司+方向。

    093ed68ee4a5049300a109e03e3eede6.png

    展开全文
  • 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>
    

    展开全文
  • 基于matlab2019a编写的程序 深度置信网络时间序列预测,已经调好的程序,换了数据就可以用。无标签训练 划分训练集和测试集
  • 深度置信网络(Deep belief network)matlab初解

    千次阅读 热门讨论 2017-08-12 11:08:24
    2、深度置信网络的训练中,首先进行初始化参数和网络结构,然后依据RBM来训练DBN中每一层的网络参数,然后将训练得到的参数作为深度神经网络的每一层参数,之后使用常规的BP神经网络扩展而来的深度神经网络方法,对...

    本文布局如下:首先是本文的基本思想,然后结合实例给出程序输入输出接口,然后是每个程序所起的作用,之后是具体每个程序的matlab实现,再之后是相关的备注;
    一、基本思想
    1、首先引入实例,然后训练深度置信网络,然后进行测试;
    2、深度置信网络的训练中,首先进行初始化参数和网络结构,然后依据RBM来训练DBN中每一层的网络参数,然后将训练得到的参数作为深度神经网络的每一层参数,之后使用常规的BP神经网络扩展而来的深度神经网络方法,对深度神经网络的参数进行更新;
    3、RBM层与层之间的实现:将上一层的隐层输出作为当前层的可视层输入
    4、RBM层内的训练方法:生成有多个样本组成的批次,然后依据对比散度方法(Contrastive Divergence -1)使用概率函数反复生成隐层和可视层的显隐性(v1-h1-v2-h2),然后据此求解该层的各类型参数(权重W,可视层偏置b,隐层偏置c)的增量及最后值
    二、输入输出接口
    本文以MNIST手写数字识别为研究对象,输入的是10000幅像素为28*28的手写图片,输出的是图片所属的类别(1-10,这10个数字)
    对于其他例子,分类问题,亦是如此
    三、相关函数
    1、function test_example_DBN:主程序,导入样本集,用于训练和测试生成神经网络
    2、function dbn = dbnsetup(dbn, x, opts):对于DBN中多层限制玻尔兹曼机(Restricted Boltzmann Machine)的参数初始化
    3、function dbn = dbntrain(dbn, x, opts):训练DBN网络,对DBN中多层RBM中的每一层RBM进行训练
    4、function rbm = rbmtrain(rbm, x, opts):具体实现每一层RBM的参数求解
    5、function x = rbmup(rbm, x):在上一层RBM求解完毕后,将上一层中的隐层输出作为本层可视层输入
    6、function nn = dbnunfoldtonn(dbn, outputsize):将生成的多层RBM转换成多层的神经网络(这里看出所训练的RBM起的主要作用是较好地实现神经网络参数的初始化)
    7、function X = sigmrnd(P):包含两块内容,一是sigmoid函数,二是根据概率选择该节点的显隐性。该函数主要用在RBM的求解中
    8、function X = sigm(P):sigmoid函数
    9、function nn = nnsetup(architecture):对深度神经网络的初始化
    10、function [nn, L] = nntrain(nn, train_x, train_y, opts, val_x, val_y):深度神经网络的训练
    11、function [er, bad] = nntest(nn, x, y):深度神经网络的测试
    之后就是深度神经网络的训练和预测部分的内容,在这里不再重复详细展开,具体内容见另一篇博文:深度神经网络
    四、具体函数
    1、function test_example_DBN

    load mnist_uint8;
    
    train_x = double(train_x) / 255;
    test_x  = double(test_x)  / 255;
    train_y = double(train_y);
    test_y  = double(test_y);
    
    %%  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
    
    %%  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');

    2、function dbn = dbnsetup(dbn, x, opts)

    n = size(x, 2);
        dbn.sizes = [n, dbn.sizes];
    
        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
    
    end

    3、function dbn = dbntrain(dbn, x, opts)

    n = numel(dbn.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

    4、function rbm = rbmtrain(rbm, x, opts)

    assert(isfloat(x), 'x must be a float');
        assert(all(x(:)>=0) && all(x(:)<=1), 'all data in x must be in [0:1]');
        m = size(x, 1);
        numbatches = m / opts.batchsize;
    
        assert(rem(numbatches, 1) == 0, 'numbatches not integer');
    
        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');
                v2 = sigmrnd(repmat(rbm.b', opts.batchsize, 1) + h1 * rbm.W);
                h2 = sigm(repmat(rbm.c', opts.batchsize, 1) + v2 * rbm.W');
    
                c1 = h1' * v1;
                c2 = h2' * v2;
    
                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
    
            disp(['epoch ' num2str(i) '/' num2str(opts.numepochs)  '. Average reconstruction error is: ' num2str(err / numbatches)]);
    
        end
    end

    5、function x = rbmup(rbm, x)

      x = sigm(repmat(rbm.c', size(x, 1), 1) + x * rbm.W');
    end
    

    6、function nn = dbnunfoldtonn(dbn, outputsize)

    %DBNUNFOLDTONN Unfolds a DBN to a NN
    %   dbnunfoldtonn(dbn, outputsize ) returns the unfolded dbn with a final
    %   layer of size outputsize added.
        if(exist('outputsize','var'))
            size = [dbn.sizes outputsize];
        else
            size = [dbn.sizes];
        end
        nn = nnsetup(size);
        for i = 1 : numel(dbn.rbm)
            nn.W{i} = [dbn.rbm{i}.c dbn.rbm{i}.W];
        end
    end
    

    7、function X = sigmrnd(P)

    %     X = double(1./(1+exp(-P)))+1*randn(size(P));
        X = double(1./(1+exp(-P)) > rand(size(P)));
    end
    

    8、function X = sigm(P)

        X = 1./(1+exp(-P));
    end
    

    9、function nn = nnsetup(architecture)
    10、function [nn, L] = nntrain(nn, train_x, train_y, opts, val_x, val_y)
    。。。(见相关深度神经网络部分的内容)

    五、参考文献
    https://github.com/rasmusbergpalm/DeepLearnToolbox
    注:该深度学习工具箱主要是针对于matlab而言的,属于源代码级别的,相对于研究生而言,逻辑清晰比较易懂;但是在实际的工程应用中,多使用python编程语言,并且也有许多大公司出产的相对更加健全的平台,如tensorflow,theano等;因此本文只是用来结合论文,来理解其基本思想,基础入门研究之用

    展开全文
  • 深度置信网络DBN

    2018-08-17 21:09:58
    DBN实例,运行与matlab版本有关系,注释详细,建议用2014版
  • 本文从序列到序列的角度重新审视了深度估计问题,以使用位置信息和注意力将cost volume construction替换为密集的像素匹配。表现SOTA!性能优于Bi3D、GwcNet和LEAStereo网络,代码刚刚开源!Revisiting Stereo Depth...

    eecbd0f2216458ef35b80a41f25232d9.png

    Transformer大法好!本文从序列到序列的角度重新审视了深度估计问题,以使用位置信息和注意力将cost volume construction替换为密集的像素匹配。表现SOTA!性能优于Bi3D、GwcNet和LEAStereo网络,代码刚刚开源!

    Revisiting Stereo Depth Estimation From a Sequence-to-Sequence Perspective with Transformers

    942883e5c021071b34b2362f9e210711.png
    作者单位:约翰·霍普金斯大学
    代码:https://github.com/mli0603/stereo-transformer
    论文:https://arxiv.org/abs/2011.02910

    注:文末附深度估计学习交流群。如果上述论文链接无法访问,可以看文末,论文已上传至百度云,方便下载。

    立体深度估计依赖于左右图像中对极线上像素之间的最佳对应匹配来推断深度。在这项工作中,我们没有从各个像素上进行匹配,而是从序列到序列的对应角度重新审视了该问题,以使用位置信息和注意力将cost volume construction替换为密集的像素匹配。这种称为STereo TRansformer(STTR)的方法具有以下优点:

    1)放宽了固定视差范围的限制,

    2)识别被遮挡的区域并提供估计的置信度,

    3)在匹配过程中施加了唯一性约束。

    d01faad7ce57994b668bc59cdadabe98.png

    c10d971123bba725d233b57b3af8fe56.png

    3f580fbbcaa46e14b0860df5056e0e10.png

    实验结果

    我们在合成数据集和实际数据集上均报告了不错的结果,并证明STTR可以很好地在不同领域进行泛化,即使没有进行微调也是如此。

    c7ecca23997ba9a24f3e383c1531c10b.png
    参数量还是很有优势的

    ea53b293a51102418d1f15b5941f2a69.png

    3fe8a9615d7edf3329e3a2e3858f23d8.png

    4d3f1faa260036569f37edc8019948ae.png

    论文下载

    链接:https://pan.baidu.com/s/1gj3PmGHK7arWoBApExhiOg
    提取码:cver

    CVer-深度估计学术交流群

    建了CVer-深度估计微信交流群!想要进深度估计学习交流群的同学,可以直接加微信号:CVer5555。加的时候备注一下:深度估计+学校+昵称,即可。然后就可以拉你进群了。

    强烈推荐大家关注CVer知乎账号和CVer微信公众号,可以快速了解到最新优质的CV论文。

    推荐阅读

    用GAN生成70岁的你!还可以重返17岁,代码已开源!ECCV 2020 Adobe等新研究

    WACV2021 | 用于小目标检测的FPN中的高效融合因子

    综述 | 对比自监督学习技术:全面调研

    85.4 mIOU!NVIDIA:使用多尺度注意力进行语义分割

    深入研究Label Smoothing(标签平滑)

    使用PyTorch时,最常见的4个错误

    NeurIPS 2020 | Auto-Panoptic:用于全景分割的协作式多组件体系结构搜索

    NeurIPS 20 | RelationNet++: Transformer桥接视觉表示的目标检测

    利用YOLOv4和Deep SORT实现多摄像头实时目标跟踪和计数(已开源)

    NeurIPS 20 | 超越EfficientNet!TinyNet:玩转网络的分辨率,深度和宽度

    涨点技巧!汇集13个Kaggle图像分类项目的性能提升指南

    利用知识蒸馏改进目标检测:面向准确高效的检测器

    使用深度学习从视频中估计车辆的速度(已开源)

    ECCV 2020 | 旷视开源LabelEnc:提升目标检测的新型中间监督方法

    这9个技巧让你的PyTorch模型训练得飞快!

    牛津博士论文 | 学习重建和分割3D目标(143页PDF)

    谷歌刚刚发布Objectron新数据集,可完美检测3D目标,超过4百万幅图像和15K视频剪辑!

    综述 | MIT提出视频理解/行为识别:全面调研(2004-2020)

    综述 | 基于无人机的目标跟踪的相关滤波器:全面调研

    从三个维度加速你的CNN:全面的剪枝框架

    Recall Loss:用于不平衡图像分类和语义分割的召回损失

    即插即用!Rotate to Attend:卷积Triplet注意力模块

    旷视提出MegDetV2:目标检测/实例分割系统

    综述 | 基于深度学习的医学图像分割技术:全面调研

    ResNet还是DenseNet?即插即用的DS涨点神器来了!

    综述 | 基于深度学习的端到端人脸识别技术:全面调研

    TBC:共享Thinner Filters,实现更强的CNN!

    综述 | 行人检测技术(从手工特征到深度学习):全面调研

    超越EfficientNets!无需注意力,也能让你的网络更快更强!

    OpenCV 4.5来了!更强的SIFT,改进RANSAC算法,新增目标跟踪网络SiamRPN++

    综述 | 基于深度学习的实时语义分割方法:全面调研

    涨点神器!南航提出AFF:注意力特征融合

    NeurIPS 2020 | 谷歌大脑提出:重新思考预训练和自训练

    NeurIPS 2020 | 用于图像复原/恢复的神经稀疏表示

    NeurIPS 2020 | aLRPLoss:统一目标检测中的分类和定位的平衡损失函数

    CCE:具有互补交叉熵的不平衡图像分类

    谷歌地标检索2020 Kaggle 第一名解决方案

    ECCV AIM 2020 真实图像超分辨率挑战赛3项冠军解决方案

    LVIS 实例分割挑战赛2020的第一名解决方案:好的Box不能保证好的Mask

    ETH Zurich提出DPIR:具有Denoiser先验的即插即用图像恢复

    ECCV 2020 | NAS-DIP:通过NAS实现DIP(去噪/去雾/超分辨率/修复等)

    综述 | 小样本学习:全面调研(Few-shot)

    使用深度神经网络从Noisy Labels中学习:全面调研

    剪枝filter?还是剪枝layer?这是个问题

    ECCV 2020 | WeightNet:重新探索Weight网络的设计空间

    ECCV 2020 | 53.5 AP!PAA:用于目标检测的IoU预测的概率Anchor分配

    ECCV 2020 | 南京理工提出FPT:特征金字塔Transformer

    ECCV 2020 | BMask R-CNN:边界保持的Mask R-CNN

    ECCV 2020 | 即插即用!PSConv:将特征金字塔压缩到紧凑

    展开全文
  • 今天帮群里的一个群友调matlab代码,CDBN,卷积深度置信网络,他说的是这个错误改了好几天都没法改,其实就是matlab如何调用c语言的问题,挺简单的。下面说说我的做法和如何在matlab中调用c语言的问题。 有一个通俗...
  • 在Reducing the Dimensionality of Data with Neural Networks中,作者给出关于MNIST的MATLAB程序的输入层是二进制向量的集合,那么当我想用连续数值输入时,应该以什么形式进行输入?需要对数据进行一些预处理吗?
  • DBN网络

    2020-11-21 22:49:34
    原理网址:深度学习-深度信念(置信网络(DBN)-从原理到实现(DeepLearnToolBox) 需要注意:第一个网址中的代码要安装DeepLearnToolBox工具箱以后才可以运行 工具箱免费下载网址:github 工具箱安装网址:Matlab...
  • 这是对深度置信网络的进一步优化,构成了一个分类器,可依据变压器的特征气体,对变压器的故障进行诊断分析,其中附带完整可运行的MATLAB代码。
  • 结合深度置信网络(DBN)在提取特征和处理高维、非线性数据等方面的优势,提出一种基于深度置信网络的分类方法。该方法通过深度学习利用原始时域信号的傅里叶频谱(FFT)训练深度置信网络,其优势在于该方法对信号...
  • 为提高天气研究和预报(Weather Research and Forecasting,WRF) 数值模式风速预报的准确度,引入深度置信网络 (Deep Belief Nets,DBN) ,构建了基于WRF数值模型的DBN风速预测模型。利用WRF数值模式进行风速预报,将...
  • 深度极限学习机(DELM)目前主要含两种基本结构:1、利用传统深度学习框架(主要是堆栈自动编码器,或者是深度置信网络)进行数据的深度自适应特征提取,而后将获得的特征输入至极限学习机及其变种中进行分类或回归;...
  • Matlab以其强大的功能和易学性一直成为科学计算领域的首选.Matlab广泛用于物理,通信技术,生物信息,航天等领域的仿真建模和数值计算.Matlab受到广泛欢迎的原因...提供深度置信网络,卷积神经网络,神经网络,栈式自编码...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

深度置信网络matlab

matlab 订阅