当前位置:   article > 正文

【转帖】【面向代码】学习 Deep Learning(一)Neural Network

【转帖】【面向代码】学习 Deep Learning(一)Neural Network

最近一直在看Deep Learning,各类博客、论文看得不少

但是说实话,这样做有些疏于实现,一来呢自己的电脑也不是很好,二来呢我目前也没能力自己去写一个toolbox

只是跟着Andrew Ng的UFLDL tutorial 写了些已有框架的代码(这部分的代码见github)

后来发现了一个matlab的Deep Learning的toolbox,发现其代码很简单,感觉比较适合用来学习算法

再一个就是matlab的实现可以省略掉很多数据结构的代码,使算法思路非常清晰

所以我想在解读这个toolbox的代码的同时来巩固自己学到的,同时也为下一步的实践打好基础

(本文只是从代码的角度解读算法,具体的算法理论步骤还是需要去看paper的

我会在文中给出一些相关的paper的名字,本文旨在梳理一下算法过程,不会深究算法原理和公式)

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

使用的代码:DeepLearnToolbox   ,下载地址:点击打开,感谢该toolbox的作者

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

第一章从分析NN(neural network)开始,因为这是整个deep learning的大框架,参见UFLDL

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

首先看一下\tests\test_example_NN.m ,跳过对数据进行normalize的部分,最关键的就是:

(为了注释显示有颜色,我把matlab代码中的%都改成了//)

 

  1. nn = nnsetup([784 100 10]);  
  2. opts.numepochs =  1;   //  Number of full sweeps through data  
  3. opts.batchsize = 100;  //  Take a mean gradient step over this many samples  
  4. [nn, L] = nntrain(nn, train_x, train_y, opts);  
  5. [er, bad] = nntest(nn, test_x, test_y);  
  1. nn = nnsetup([784 100 10]);
  2. opts.numepochs = 1; // Number of full sweeps through data
  3. opts.batchsize = 100; // Take a mean gradient step over this many samples
  4. [nn, L] = nntrain(nn, train_x, train_y, opts);
  5. [er, bad] = nntest(nn, test_x, test_y);

 

很简单的几步就训练了一个NN,我们发现其中最重要的几个函数就是nnsetup,nntrain和nntest了

 

那么我们分别来分析着几个函数,\NN\nnsetup.m

nnsetup

 

  1. function nn = nnsetup(architecture)  
  2. //首先从传入的architecture中获得这个网络的整体结构,nn.n表示这个网络有多少层,可以参照上面的样例调用nnsetup([784 100 10])加以理解  
  3.   
  4.     nn.size   = architecture;  
  5.     nn.n      = numel(nn.size);  
  6.     //接下来是一大堆的参数,这个我们到具体用的时候再加以说明  
  7.     nn.activation_function              = 'tanh_opt';   //  Activation functions of hidden layers: 'sigm' (sigmoid) or 'tanh_opt' (optimal tanh).  
  8.     nn.learningRate                     = 2;            //  learning rate Note: typically needs to be lower when using 'sigm' activation function and non-normalized inputs.  
  9.     nn.momentum                         = 0.5;          //  Momentum  
  10.     nn.scaling_learningRate             = 1;            //  Scaling factor for the learning rate (each epoch)  
  11.     nn.weightPenaltyL2                  = 0;            //  L2 regularization  
  12.     nn.nonSparsityPenalty               = 0;            //  Non sparsity penalty  
  13.     nn.sparsityTarget                   = 0.05;         //  Sparsity target  
  14.     nn.inputZeroMaskedFraction          = 0;            //  Used for Denoising AutoEncoders  
  15.     nn.dropoutFraction                  = 0;            //  Dropout level (http://www.cs.toronto.edu/~hinton/absps/dropout.pdf)  
  16.     nn.testing                          = 0;            //  Internal variable. nntest sets this to one.  
  17.     nn.output                           = 'sigm';       //  output unit 'sigm' (=logistic), 'softmax' and 'linear'  
  18.     //对每一层的网络结构进行初始化,一共三个参数W,vW,p,其中W是主要的参数    
  19.     //vW是更新参数时的临时参数,p是所谓的sparsity,(等看到代码了再细讲)      
  20.    for i = 2 : nn.n     
  21.         // weights and weight momentum  
  22.         nn.W{i - 1} = (rand(nn.size(i), nn.size(i - 1)+1) - 0.5) * 2 * 4 * sqrt(6 / (nn.size(i) + nn.size(i - 1)));  
  23.         nn.vW{i - 1} = zeros(size(nn.W{i - 1}));  
  24.           
  25.         // average activations (for use with sparsity)  
  26.         nn.p{i}     = zeros(1, nn.size(i));     
  27.     end  
  28. end  
  1. function nn = nnsetup(architecture)
  2. //首先从传入的architecture中获得这个网络的整体结构,nn.n表示这个网络有多少层,可以参照上面的样例调用nnsetup([784 100 10])加以理解
  3. nn.size = architecture;
  4. nn.n = numel(nn.size);
  5. //接下来是一大堆的参数,这个我们到具体用的时候再加以说明
  6. nn.activation_function = 'tanh_opt'; // Activation functions of hidden layers: 'sigm' (sigmoid) or 'tanh_opt' (optimal tanh).
  7. nn.learningRate = 2; // learning rate Note: typically needs to be lower when using 'sigm' activation function and non-normalized inputs.
  8. nn.momentum = 0.5; // Momentum
  9. nn.scaling_learningRate = 1; // Scaling factor for the learning rate (each epoch)
  10. nn.weightPenaltyL2 = 0; // L2 regularization
  11. nn.nonSparsityPenalty = 0; // Non sparsity penalty
  12. nn.sparsityTarget = 0.05; // Sparsity target
  13. nn.inputZeroMaskedFraction = 0; // Used for Denoising AutoEncoders
  14. nn.dropoutFraction = 0; // Dropout level (http://www.cs.toronto.edu/~hinton/absps/dropout.pdf)
  15. nn.testing = 0; // Internal variable. nntest sets this to one.
  16. nn.output = 'sigm'; // output unit 'sigm' (=logistic), 'softmax' and 'linear'
  17. //对每一层的网络结构进行初始化,一共三个参数W,vW,p,其中W是主要的参数
  18. //vW是更新参数时的临时参数,p是所谓的sparsity,(等看到代码了再细讲)
  19. for i = 2 : nn.n
  20. // weights and weight momentum
  21. nn.W{i - 1} = (rand(nn.size(i), nn.size(i - 1)+1) - 0.5) * 2 * 4 * sqrt(6 / (nn.size(i) + nn.size(i - 1)));
  22. nn.vW{i - 1} = zeros(size(nn.W{i - 1}));
  23. // average activations (for use with sparsity)
  24. nn.p{i} = zeros(1, nn.size(i));
  25. end
  26. end

nntrain

setup大概就这样一个过程,下面就到了train了,打开\NN\nntrain.m

我们跳过那些检验传入数据是否正确的代码,直接到关键的部分

denoising 的部分请参考论文:Extracting and Composing Robust Features with Denoising Autoencoders

 

  1. m = size(train_x, 1);  
  2. //m是训练样本的数量  
  3. //注意在调用的时候我们设置了opt,batchsize是做batch gradient时候的大小  
  4. batchsize = opts.batchsize; numepochs = opts.numepochs;  
  5. numbatches = m / batchsize;  //计算batch的数量  
  6. assert(rem(numbatches, 1) == 0, 'numbatches must be a integer');  
  7. L = zeros(numepochs*numbatches,1);  
  8. n = 1;  
  9. //numepochs是循环的次数  
  10. for i = 1 : numepochs  
  11.     tic;  
  12.     kk = randperm(m);  
  13.     //把batches打乱顺序进行训练,randperm(m)生成一个乱序的1到m的数组  
  14.     for l = 1 : numbatches  
  15.         batch_x = train_x(kk((l - 1) * batchsize + 1 : l * batchsize), :);  
  16.         //Add noise to input (for use in denoising autoencoder)  
  17.         //加入noise,这是denoising autoencoder需要使用到的部分  
  18.         //这部分请参见《Extracting and Composing Robust Features with Denoising Autoencoders》这篇论文  
  19.         //具体加入的方法就是把训练样例中的一些数据调整变为0,inputZeroMaskedFraction表示了调整的比例  
  20.         if(nn.inputZeroMaskedFraction ~= 0)  
  21.             batch_x = batch_x.*(rand(size(batch_x))>nn.inputZeroMaskedFraction);  
  22.         end  
  23.         batch_y = train_y(kk((l - 1) * batchsize + 1 : l * batchsize), :);  
  24.         //这三个函数  
  25.         //nnff是进行前向传播,nnbp是后向传播,nnapplygrads是进行梯度下降  
  26.         //我们在下面分析这些函数的代码  
  27.         nn = nnff(nn, batch_x, batch_y);  
  28.         nn = nnbp(nn);  
  29.         nn = nnapplygrads(nn);  
  30.         L(n) = nn.L;  
  31.         n = n + 1;  
  32.     end  
  33.       
  34.     t = toc;  
  35.     if ishandle(fhandle)  
  36.         if opts.validation == 1  
  37.             loss = nneval(nn, loss, train_x, train_y, val_x, val_y);  
  38.         else  
  39.             loss = nneval(nn, loss, train_x, train_y);  
  40.         end  
  41.         nnupdatefigures(nn, fhandle, loss, opts, i);  
  42.     end  
  43.           
  44.     disp(['epoch ' num2str(i) '/' num2str(opts.numepochs) '. Took ' num2str(t) ' seconds' '. Mean squared error on training set is ' num2str(mean(L((n-numbatches):(n-1))))]);  
  45.     nn.learningRate = nn.learningRate * nn.scaling_learningRate;  
  46. end  
  1. m = size(train_x, 1);
  2. //m是训练样本的数量
  3. //注意在调用的时候我们设置了opt,batchsize是做batch gradient时候的大小
  4. batchsize = opts.batchsize; numepochs = opts.numepochs;
  5. numbatches = m / batchsize; //计算batch的数量
  6. assert(rem(numbatches, 1) == 0, 'numbatches must be a integer');
  7. L = zeros(numepochs*numbatches,1);
  8. n = 1;
  9. //numepochs是循环的次数
  10. for i = 1 : numepochs
  11. tic;
  12. kk = randperm(m);
  13. //把batches打乱顺序进行训练,randperm(m)生成一个乱序的1到m的数组
  14. for l = 1 : numbatches
  15. batch_x = train_x(kk((l - 1) * batchsize + 1 : l * batchsize), :);
  16. //Add noise to input (for use in denoising autoencoder)
  17. //加入noise,这是denoising autoencoder需要使用到的部分
  18. //这部分请参见《Extracting and Composing Robust Features with Denoising Autoencoders》这篇论文
  19. //具体加入的方法就是把训练样例中的一些数据调整变为0,inputZeroMaskedFraction表示了调整的比例
  20. if(nn.inputZeroMaskedFraction ~= 0)
  21. batch_x = batch_x.*(rand(size(batch_x))>nn.inputZeroMaskedFraction);
  22. end
  23. batch_y = train_y(kk((l - 1) * batchsize + 1 : l * batchsize), :);
  24. //这三个函数
  25. //nnff是进行前向传播,nnbp是后向传播,nnapplygrads是进行梯度下降
  26. //我们在下面分析这些函数的代码
  27. nn = nnff(nn, batch_x, batch_y);
  28. nn = nnbp(nn);
  29. nn = nnapplygrads(nn);
  30. L(n) = nn.L;
  31. n = n + 1;
  32. end
  33. t = toc;
  34. if ishandle(fhandle)
  35. if opts.validation == 1
  36. loss = nneval(nn, loss, train_x, train_y, val_x, val_y);
  37. else
  38. loss = nneval(nn, loss, train_x, train_y);
  39. end
  40. nnupdatefigures(nn, fhandle, loss, opts, i);
  41. end
  42. disp(['epoch ' num2str(i) '/' num2str(opts.numepochs) '. Took ' num2str(t) ' seconds' '. Mean squared error on training set is ' num2str(mean(L((n-numbatches):(n-1))))]);
  43. nn.learningRate = nn.learningRate * nn.scaling_learningRate;
  44. end

下面分析三个函数nnff,nnbp和nnapplygrads

 

nnff

nnff就是进行feedforward pass,其实非常简单,就是整个网络正向跑一次就可以了

当然其中有dropout和sparsity的计算

具体的参见论文“Improving Neural Networks with Dropout“和Autoencoders and Sparsity

  1. function nn = nnff(nn, x, y)  
  2. //NNFF performs a feedforward pass  
  3. // nn = nnff(nn, x, y) returns an neural network structure with updated  
  4. // layer activations, error and loss (nn.a, nn.e and nn.L)  
  5.   
  6.     n = nn.n;  
  7.     m = size(x, 1);  
  8.       
  9.     x = [ones(m,1) x];  
  10.     nn.a{1} = x;  
  11.   
  12.     //feedforward pass  
  13.     for i = 2 : n-1  
  14.         //根据选择的激活函数不同进行正向传播计算  
  15.         //你可以回过头去看nnsetup里面的第一个参数activation_function  
  16.         //sigm就是sigmoid函数,tanh_opt就是tanh的函数,这个toolbox好像有一点改变  
  17.         //tanh_opt是1.7159*tanh(2/3.*A)  
  18.         switch nn.activation_function   
  19.             case 'sigm'  
  20.                 // Calculate the unit's outputs (including the bias term)  
  21.                 nn.a{i} = sigm(nn.a{i - 1} * nn.W{i - 1}');  
  22.             case 'tanh_opt'  
  23.                 nn.a{i} = tanh_opt(nn.a{i - 1} * nn.W{i - 1}');  
  24.         end  
  25.           
  26.         //dropout的计算部分部分 dropoutFraction 是nnsetup中可以设置的一个参数  
  27.         if(nn.dropoutFraction > 0)  
  28.             if(nn.testing)  
  29.                 nn.a{i} = nn.a{i}.*(1 - nn.dropoutFraction);  
  30.             else  
  31.                 nn.dropOutMask{i} = (rand(size(nn.a{i}))>nn.dropoutFraction);  
  32.                 nn.a{i} = nn.a{i}.*nn.dropOutMask{i};  
  33.             end  
  34.         end  
  35.         //计算sparsity,nonSparsityPenalty 是对没达到sparsitytarget的参数的惩罚系数  
  36.         //calculate running exponential activations for use with sparsity  
  37.         if(nn.nonSparsityPenalty>0)  
  38.             nn.p{i} = 0.99 * nn.p{i} + 0.01 * mean(nn.a{i}, 1);  
  39.         end  
  40.           
  41.         //Add the bias term  
  42.         nn.a{i} = [ones(m,1) nn.a{i}];  
  43.     end  
  44.     switch nn.output   
  45.         case 'sigm'  
  46.             nn.a{n} = sigm(nn.a{n - 1} * nn.W{n - 1}');  
  47.         case 'linear'  
  48.             nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';  
  49.         case 'softmax'  
  50.             nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';  
  51.             nn.a{n} = exp(bsxfun(@minus, nn.a{n}, max(nn.a{n},[],2)));  
  52.             nn.a{n} = bsxfun(@rdivide, nn.a{n}, sum(nn.a{n}, 2));   
  53.     end  
  54.     //error and loss  
  55.     //计算error  
  56.     nn.e = y - nn.a{n};  
  57.       
  58.     switch nn.output  
  59.         case {'sigm', 'linear'}  
  60.             nn.L = 1/2 * sum(sum(nn.e .^ 2)) / m;   
  61.         case 'softmax'  
  62.             nn.L = -sum(sum(y .* log(nn.a{n}))) / m;  
  63.     end  
  64. end  
  1. function nn = nnff(nn, x, y)
  2. //NNFF performs a feedforward pass
  3. // nn = nnff(nn, x, y) returns an neural network structure with updated
  4. // layer activations, error and loss (nn.a, nn.e and nn.L)
  5. n = nn.n;
  6. m = size(x, 1);
  7. x = [ones(m,1) x];
  8. nn.a{1} = x;
  9. //feedforward pass
  10. for i = 2 : n-1
  11. //根据选择的激活函数不同进行正向传播计算
  12. //你可以回过头去看nnsetup里面的第一个参数activation_function
  13. //sigm就是sigmoid函数,tanh_opt就是tanh的函数,这个toolbox好像有一点改变
  14. //tanh_opt是1.7159*tanh(2/3.*A)
  15. switch nn.activation_function
  16. case 'sigm'
  17. // Calculate the unit's outputs (including the bias term)
  18. nn.a{i} = sigm(nn.a{i - 1} * nn.W{i - 1}');
  19. case 'tanh_opt'
  20. nn.a{i} = tanh_opt(nn.a{i - 1} * nn.W{i - 1}');
  21. end
  22. //dropout的计算部分部分 dropoutFraction 是nnsetup中可以设置的一个参数
  23. if(nn.dropoutFraction > 0)
  24. if(nn.testing)
  25. nn.a{i} = nn.a{i}.*(1 - nn.dropoutFraction);
  26. else
  27. nn.dropOutMask{i} = (rand(size(nn.a{i}))>nn.dropoutFraction);
  28. nn.a{i} = nn.a{i}.*nn.dropOutMask{i};
  29. end
  30. end
  31. //计算sparsity,nonSparsityPenalty 是对没达到sparsitytarget的参数的惩罚系数
  32. //calculate running exponential activations for use with sparsity
  33. if(nn.nonSparsityPenalty>0)
  34. nn.p{i} = 0.99 * nn.p{i} + 0.01 * mean(nn.a{i}, 1);
  35. end
  36. //Add the bias term
  37. nn.a{i} = [ones(m,1) nn.a{i}];
  38. end
  39. switch nn.output
  40. case 'sigm'
  41. nn.a{n} = sigm(nn.a{n - 1} * nn.W{n - 1}');
  42. case 'linear'
  43. nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';
  44. case 'softmax'
  45. nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';
  46. nn.a{n} = exp(bsxfun(@minus, nn.a{n}, max(nn.a{n},[],2)));
  47. nn.a{n} = bsxfun(@rdivide, nn.a{n}, sum(nn.a{n}, 2));
  48. end
  49. //error and loss
  50. //计算error
  51. nn.e = y - nn.a{n};
  52. switch nn.output
  53. case {'sigm', 'linear'}
  54. nn.L = 1/2 * sum(sum(nn.e .^ 2)) / m;
  55. case 'softmax'
  56. nn.L = -sum(sum(y .* log(nn.a{n}))) / m;
  57. end
  58. end

 

nnbp

 

代码:\NN\nnbp.m

nnbp呢是进行back propagation的过程,过程还是比较中规中矩,和ufldl中的Neural Network讲的基本一致

值得注意的还是dropout和sparsity的部分

  1. if(nn.nonSparsityPenalty>0)  
  2.     pi = repmat(nn.p{i}, size(nn.a{i}, 1), 1);  
  3.     sparsityError = [zeros(size(nn.a{i},1),1) nn.nonSparsityPenalty * (-nn.sparsityTarget ./ pi + (1 - nn.sparsityTarget) ./ (1 - pi))];  
  4. end  
  5.   
  6. // Backpropagate first derivatives  
  7. if i+1==n % in this case in d{n} there is not the bias term to be removed               
  8.     d{i} = (d{i + 1} * nn.W{i} + sparsityError) .* d_act; // Bishop (5.56)  
  9. else // in this case in d{i} the bias term has to be removed  
  10.     d{i} = (d{i + 1}(:,2:end) * nn.W{i} + sparsityError) .* d_act;  
  11. end  
  12.   
  13. if(nn.dropoutFraction>0)  
  14.     d{i} = d{i} .* [ones(size(d{i},1),1) nn.dropOutMask{i}];  
  15. end  
  1. if(nn.nonSparsityPenalty>0)
  2. pi = repmat(nn.p{i}, size(nn.a{i}, 1), 1);
  3. sparsityError = [zeros(size(nn.a{i},1),1) nn.nonSparsityPenalty * (-nn.sparsityTarget ./ pi + (1 - nn.sparsityTarget) ./ (1 - pi))];
  4. end
  5. // Backpropagate first derivatives
  6. if i+1==n % in this case in d{n} there is not the bias term to be removed
  7. d{i} = (d{i + 1} * nn.W{i} + sparsityError) .* d_act; // Bishop (5.56)
  8. else // in this case in d{i} the bias term has to be removed
  9. d{i} = (d{i + 1}(:,2:end) * nn.W{i} + sparsityError) .* d_act;
  10. end
  11. if(nn.dropoutFraction>0)
  12. d{i} = d{i} .* [ones(size(d{i},1),1) nn.dropOutMask{i}];
  13. end

这只是实现的内容,代码中的d{i}就是这一层的delta值,在ufldl中有讲的

 

dW{i}基本就是计算的gradient了,只是后面还要加入一些东西,进行一些修改

具体原理参见论文“Improving Neural Networks with Dropout“ 以及 Autoencoders and Sparsity的内容

nnapplygrads

代码文件:\NN\nnapplygrads.m

  1. for i = 1 : (nn.n - 1)  
  2.     if(nn.weightPenaltyL2>0)  
  3.         dW = nn.dW{i} + nn.weightPenaltyL2 * nn.W{i};  
  4.     else  
  5.         dW = nn.dW{i};  
  6.     end  
  7.       
  8.     dW = nn.learningRate * dW;  
  9.       
  10.     if(nn.momentum>0)  
  11.         nn.vW{i} = nn.momentum*nn.vW{i} + dW;  
  12.         dW = nn.vW{i};  
  13.     end  
  14.           
  15.     nn.W{i} = nn.W{i} - dW;  
  16. end  
  1. for i = 1 : (nn.n - 1)
  2. if(nn.weightPenaltyL2>0)
  3. dW = nn.dW{i} + nn.weightPenaltyL2 * nn.W{i};
  4. else
  5. dW = nn.dW{i};
  6. end
  7. dW = nn.learningRate * dW;
  8. if(nn.momentum>0)
  9. nn.vW{i} = nn.momentum*nn.vW{i} + dW;
  10. dW = nn.vW{i};
  11. end
  12. nn.W{i} = nn.W{i} - dW;
  13. end

这个内容就简单了,nn.weightPenaltyL2 是weight decay的部分,也是nnsetup时可以设置的一个参数

 

有的话就加入weight Penalty,防止过拟合,然后再根据momentum的大小调整一下,最后改变nn.W{i}即可

nntest

nntest再简单不过了,就是调用一下nnpredict,在和test的集合进行比较

  1. function [er, bad] = nntest(nn, x, y)  
  2.     labels = nnpredict(nn, x);  
  3.     [~, expected] = max(y,[],2);  
  4.     bad = find(labels ~= expected);      
  5.     er = numel(bad) / size(x, 1);  
  6. end  
  1. function [er, bad] = nntest(nn, x, y)
  2. labels = nnpredict(nn, x);
  3. [~, expected] = max(y,[],2);
  4. bad = find(labels ~= expected);
  5. er = numel(bad) / size(x, 1);
  6. end

 

nnpredict

 

代码文件:\NN\nnpredict.m

  1. function labels = nnpredict(nn, x)  
  2.     nn.testing = 1;  
  3.     nn = nnff(nn, x, zeros(size(x,1), nn.size(end)));  
  4.     nn.testing = 0;  
  5.       
  6.     [~, i] = max(nn.a{end},[],2);  
  7.     labels = i;  
  8. end  
  1. function labels = nnpredict(nn, x)
  2. nn.testing = 1;
  3. nn = nnff(nn, x, zeros(size(x,1), nn.size(end)));
  4. nn.testing = 0;
  5. [~, i] = max(nn.a{end},[],2);
  6. labels = i;
  7. end

继续非常简单,predict不过是nnff一次,得到最后的output~~

 

max(nn.a{end},[],2); 是返回每一行的最大值以及所在的列数,所以labels返回的就是标号啦

(这个test好像是专门用来test 分类问题的,我们知道nnff得到最后的值即可)

 

总结

 
   总的来说,神经网络的代码比较常规易理解,基本上和 UFLDL中的内容相差不大
   只是加入了dropout的部分和denoising的部分
   本文的目的也不奢望讲清楚这些东西,只是给出一个路线,可以跟着代码去学习,加深对算法的理解和应用能力

转载于:https://www.cnblogs.com/daleloogn/p/4162459.html

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/weixin_40725706/article/detail/695314
推荐阅读
相关标签
  

闽ICP备14008679号