【面向代码】学习 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

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

首先看一下 ests est_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);  

那么我们分别来分析着几个函数，NN nsetup.m

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  

setup大概就这样一个过程，下面就到了train了，打开NN ntrain.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  

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  

代码：NN nbp.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  

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

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

代码文件：NN napplygrads.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  

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

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  

代码文件：NN npredict.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  

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

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

   总的来说，神经网络的代码比较常规易理解，基本上和UFLDL中的内容相差不大

   只是加入了dropout的部分和denoising的部分

   本文的目的也不奢望讲清楚这些东西，只是给出一个路线，可以跟着代码去学习，加深对算法的理解和应用能力