机器学习笔记（四）神经网络学习算法

第五章神经网络学习算法

1.一些标记：L层数，sl表示层的神经元个数（不包括a0），k输出层的个数

2.神经网络的代价函数（不再是凸函数了，会有局部最值。尽管这样，在使用梯度下降算法后，一般仍然表现很好）

求代价函数的前向传播算法：

3.反向传播算法

理解：http://ufldl.stanford.edu/wiki/index.php/%E5%8F%8D%E5%90%91%E4%BC%A0%E5%AF%BC%E7%AE%97%E6%B3%95

4.梯度检验（可以用在前边的算法中，非常通用）

双侧差分近似求导数（斜率）

将近似倒数和用反向传播算法求得的值对比，如果差距较小，检验正确（一般几位小数后），否则可能有问题。

梯度检验是一个相对反向传播算法比较慢的求解方法，所以只用来检验，使用时，要关闭检验。

比较复杂度（大约，可以看下边的代码实现）：

设SS=max(theta*a)（即最大的矩阵乘法复杂度)，SH=所有theta的元素个数

代价函数复杂度cost=SS*m(m为训练集个数)

梯度检验复杂度=SS*cost=SS*m*SH；

反向传播算法复杂度=cost*高级梯度下降算法循环次数=SS*m*高级梯度下降算法循环次数；

5.随机初始化

在神经网络中初始化theta为全0的话，可能得不到解，使用随机初始化，rand(m,n)//产生一个m*n的矩阵，每个元素[0,1]之间

6.神经网络的步骤

构建模型
- 输入层和输出层由具体问题可知；
- 隐藏层普遍情况下是一层（较为合理）；
- 隐藏层的单元个数越多越好，但太多后计算代价增大，一般比输入特征多；
- 隐藏层如果有多层，则一般每层的单元数相同；
随机初始化theta，一般很小，接近0
前向传播算法求h(x)
求代价函数J
反向传播算法求偏导数
梯度检查（数值偏导数）确保算法正确，别忘了确定后要把梯度检查代码移除
使用高级的算法（梯度下降）求theta

代码：

1.sigmoidgradient函数（sigmoid的导数）

function g = sigmoidGradient(z)%z可能是矩阵，要用.
    g = zeros(size(z));
    g=1.0 ./(1+e .^ z);
    g=g .* (1-g);

end

2.随机初始化theta函数

function W = randInitializeWeights(L_in, L_out)%生成矩阵，每个元素在[-epsilon,epsilon]之间
    W = zeros(L_out, 1 + L_in);    

    epsilon=0.12;
    W=rand(L_out, 1 + L_in)*2*epsilon-epsilon;
end

3.神经网络的代价函数求代价and偏导数

function [J grad] = nnCostFunction(nn_params, ...
                                   input_layer_size, ...
                                   hidden_layer_size, ...
                                   num_labels, ...
                                   X, y, lambda)

    Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ...
                 hidden_layer_size, (input_layer_size + 1));

    Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ...
                 num_labels, (hidden_layer_size + 1));

    m = size(X, 1);

    J = 0;
    Theta1_grad = zeros(size(Theta1));
    Theta2_grad = zeros(size(Theta2));

%求J
    X=[ones(size(X,1),1),X];
    a1=X';
    
    z2=Theta1*a1;
    a2=sigmoid(z2);
    a2=[ones(1,size(a2,2));a2];
    
    z3=Theta2*a2;
    a3=sigmoid(z3);    
    h=a3;

    for i=1:m
        temp=zeros(num_labels,1);    %将结果y转化相应向量
        temp(y(i,1),1)=1;
        J+=-(temp' * log(h(:,i)) + (1-temp)' *log(1-h(:,i)) );
    end;
    J/=m;
%加入正则化
    J+=( sum((Theta1(:,2:end) .^2)(:)) + sum((Theta2(:,2:end) .^2)(:)) )*lambda/(m*2);

% -------------------------------------------------------------
%求grad
         
    for i=1:m
        temp=zeros(num_labels,1);
        temp(y(i,1),1)=1;
        delta3=a3(:,i)-temp;
        
        delta2=Theta2' *delta3 ;
        delta2=delta2(2:end,:);
        delta2=delta2 .* sigmoidGradient(z2(:,i));
        
        Theta2_grad+=delta3*(a2(:,i)');
        Theta1_grad+=delta2*( a1(:,i)' );
    end;
    Theta2_grad/=m;
    Theta1_grad/=m;
%加入正则化
    Theta2_grad+=[zeros(size(Theta2_grad,1),1),Theta2(:,2:end)]*lambda/m;
    Theta1_grad+=[zeros(size(Theta1_grad,1),1),Theta1(:,2:end)]*lambda/m;

% Unroll gradients
    grad = [Theta1_grad(:) ; Theta2_grad(:)];
end

4.梯度检验，及其函数调用方法

调用方法：
costFunc = @(p) nnCostFunction(p, input_layer_size, hidden_layer_size,num_labels, X, y, lambda);%函数变量
numgrad = computeNumericalGradient(costFunc, nn_params);

函数：
function numgrad = computeNumericalGradient(J, theta) %J是求代价的函数，可能有多个参数               

    numgrad = zeros(size(theta));
    perturb = zeros(size(theta));
    e = 1e-4;
    for p = 1:numel(theta)
        % Set perturbation vector
        perturb(p) = e;
        loss1 = J(theta - perturb);
        loss2 = J(theta + perturb);
        % Compute Numerical Gradient
        numgrad(p) = (loss2 - loss1) / (2*e);
        perturb(p) = 0;
    end
end;

5.整体代码：

input_layer_size  = 400;  % 20x20 Input Images of Digits
hidden_layer_size = 25;   % 25 hidden units
num_labels = 10;          % 10 labels, from 1 to 10  

load('ex4data1.mat');
m = size(X, 1);

% Randomly select 100 data points to display
%sel = randperm(size(X, 1));    
%sel = sel(1:100);
%displayData(X(sel, :));

load('ex4weights.mat');        %load theta1(25*401) and theta2(10*26)

initial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size);
initial_Theta2 = randInitializeWeights(hidden_layer_size, num_labels);

initial_nn_params=nn_params = [initial_Theta1(:) ; initial_Theta2(:)];
%checkNNGradients;

lambda = 1;
options = optimset('MaxIter', 50);
costFunction = @(p) nnCostFunction(p, ...
                                   input_layer_size, ...
                                   hidden_layer_size, ...
                                   num_labels, X, y, lambda);

[nn_params, cost] = fmincg(costFunction, initial_nn_params, options);

Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ...
                 hidden_layer_size, (input_layer_size + 1));

Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ...
                 num_labels, (hidden_layer_size + 1));

pred = predict(Theta1, Theta2, X);

fprintf('
Training Set Accuracy: %f
', mean(double(pred == y)) * 100);

解释反向传播算法：

来自：http://ufldl.stanford.edu/wiki/index.php/%E5%8F%8D%E5%90%91%E4%BC%A0%E5%AF%BC%E7%AE%97%E6%B3%95

假设我们有一个固定样本集 $extstyle { (x^{(1)}, y^{(1)}), ldots, (x^{(m)}, y^{(m)}) }$ ，它包含 $extstyle m$ 个样例。我们可以用批量梯度下降法来求解神经网络。具体来讲，对于单个样例 $extstyle (x,y)$ ，其代价函数为：

$egin{align} J(W,b; x,y) = frac{1}{2} left| h_{W,b}(x) - y ight|^2. end{align}$

这是一个（二分之一的）方差代价函数。给定一个包含 $extstyle m$ 个样例的数据集，我们可以定义整体代价函数为：

$egin{align} J(W,b) &= left[ frac{1}{m} sum_{i=1}^m J(W,b;x^{(i)},y^{(i)}) ight] + frac{lambda}{2} sum_{l=1}^{n_l-1} ; sum_{i=1}^{s_l} ; sum_{j=1}^{s_{l+1}} left( W^{(l)}_{ji} ight)^2 \ &= left[ frac{1}{m} sum_{i=1}^m left( frac{1}{2} left| h_{W,b}(x^{(i)}) - y^{(i)} ight|^2 ight) ight] + frac{lambda}{2} sum_{l=1}^{n_l-1} ; sum_{i=1}^{s_l} ; sum_{j=1}^{s_{l+1}} left( W^{(l)}_{ji} ight)^2 end{align}$

以上公式中的第一项 $extstyle J(W,b)$ 是一个均方差项。第二项是一个规则化项（也叫权重衰减项），其目的是减小权重的幅度，防止过度拟合。

[注：通常权重衰减的计算并不使用偏置项 $extstyle b^{(l)}_i$ ，比如我们在 $extstyle J(W, b)$ 的定义中就没有使用。一般来说，将偏置项包含在权重衰减项中只会对最终的神经网络产生很小的影响。如果你在斯坦福选修过CS229（机器学习）课程，或者在YouTube上看过课程视频，你会发现这个权重衰减实际上是课上提到的贝叶斯规则化方法的变种。在贝叶斯规则化方法中，我们将高斯先验概率引入到参数中计算MAP（极大后验）估计（而不是极大似然估计）。]

权重衰减参数 $extstyle lambda$ 用于控制公式中两项的相对重要性。在此重申一下这两个复杂函数的含义： $extstyle J(W,b;x,y)$ 是针对单个样例计算得到的方差代价函数； $extstyle J(W,b)$ 是整体样本代价函数，它包含权重衰减项。

以上的代价函数经常被用于分类和回归问题。在分类问题中，我们用 $extstyle y = 0$ 或 $extstyle 1$ ，来代表两种类型的标签（回想一下，这是因为 sigmoid激活函数的值域为 $extstyle [0,1]$ ；如果我们使用双曲正切型激活函数，那么应该选用 $extstyle -1$ 和 $extstyle +1$ 作为标签）。对于回归问题，我们首先要变换输出值域（译者注：也就是 $extstyle y$ ），以保证其范围为 $extstyle [0,1]$ （同样地，如果我们使用双曲正切型激活函数，要使输出值域为 $extstyle [-1,1]$ ）。

我们的目标是针对参数 $extstyle W$ 和 $extstyle b$ 来求其函数 $extstyle J(W,b)$ 的最小值。为了求解神经网络，我们需要将每一个参数 $extstyle W^{(l)}_{ij}$ 和 $extstyle b^{(l)}_i$ 初始化为一个很小的、接近零的随机值（比如说，使用正态分布 $extstyle {Normal}(0,epsilon^2)$ 生成的随机值，其中 $extstyle epsilon$ 设置为 $extstyle 0.01$ ），之后对目标函数使用诸如批量梯度下降法的最优化算法。因为 $extstyle J(W, b)$ 是一个非凸函数，梯度下降法很可能会收敛到局部最优解；但是在实际应用中，梯度下降法通常能得到令人满意的结果。最后，需要再次强调的是，要将参数进行随机初始化，而不是全部置为 $extstyle 0$ 。如果所有参数都用相同的值作为初始值，那么所有隐藏层单元最终会得到与输入值有关的、相同的函数（也就是说，对于所有 $extstyle i$ ， $extstyle W^{(1)}_{ij}$ 都会取相同的值，那么对于任何输入 $extstyle x$ 都会有： $extstyle a^{(2)}_1 = a^{(2)}_2 = a^{(2)}_3 = ldots$ ）。随机初始化的目的是使对称失效。

梯度下降法中每一次迭代都按照如下公式对参数 $extstyle W$ 和 $extstyle b$ 进行更新：

$egin{align} W_{ij}^{(l)} &= W_{ij}^{(l)} - alpha frac{partial}{partial W_{ij}^{(l)}} J(W,b) \ b_{i}^{(l)} &= b_{i}^{(l)} - alpha frac{partial}{partial b_{i}^{(l)}} J(W,b) end{align}$

其中 $extstyle alpha$ 是学习速率。其中关键步骤是计算偏导数。我们现在来讲一下反向传播算法，它是计算偏导数的一种有效方法。

我们首先来讲一下如何使用反向传播算法来计算 $extstyle frac{partial}{partial W_{ij}^{(l)}} J(W,b; x, y)$ 和 $extstyle frac{partial}{partial b_{i}^{(l)}} J(W,b; x, y)$ ，这两项是单个样例 $extstyle (x,y)$ 的代价函数 $extstyle J(W,b;x,y)$ 的偏导数。一旦我们求出该偏导数，就可以推导出整体代价函数 $extstyle J(W,b)$ 的偏导数：

$egin{align} frac{partial}{partial W_{ij}^{(l)}} J(W,b) &= left[ frac{1}{m} sum_{i=1}^m frac{partial}{partial W_{ij}^{(l)}} J(W,b; x^{(i)}, y^{(i)}) ight] + lambda W_{ij}^{(l)} \ frac{partial}{partial b_{i}^{(l)}} J(W,b) &= frac{1}{m}sum_{i=1}^m frac{partial}{partial b_{i}^{(l)}} J(W,b; x^{(i)}, y^{(i)}) end{align}$

以上两行公式稍有不同，第一行比第二行多出一项，是因为权重衰减是作用于 $extstyle W$ 而不是 $extstyle b$ 。

反向传播算法的思路如下：给定一个样例 $extstyle (x,y)$ ，我们首先进行“前向传导”运算，计算出网络中所有的激活值，包括 $extstyle h_{W,b}(x)$ 的输出值。之后，针对第 $extstyle l$ 层的每一个节点 $extstyle i$ ，我们计算出其“残差” $extstyle delta^{(l)}_i$ ，该残差表明了该节点对最终输出值的残差产生了多少影响。对于最终的输出节点，我们可以直接算出网络产生的激活值与实际值之间的差距，我们将这个差距定义为 $extstyle delta^{(n_l)}_i$ （第 $extstyle n_l$ 层表示输出层）。对于隐藏单元我们如何处理呢？我们将基于节点（译者注：第 $extstyle l+1$ 层节点）残差的加权平均值计算 $extstyle delta^{(l)}_i$ ，这些节点以 $extstyle a^{(l)}_i$ 作为输入。下面将给出反向传导算法的细节：

进行前馈传导计算，利用前向传导公式，得到 $extstyle L_2, L_3, ldots$ 直到输出层 $extstyle L_{n_l}$ 的激活值。
对于第 $extstyle n_l$ 层（输出层）的每个输出单元 $extstyle i$ ，我们根据以下公式计算残差：
$egin{align} delta^{(n_l)}_i = frac{partial}{partial z^{(n_l)}_i} ;; frac{1}{2} left|y - h_{W,b}(x) ight|^2 = - (y_i - a^{(n_l)}_i) cdot f'(z^{(n_l)}_i) end{align}$
[译者注：
$egin{align} delta^{(n_l)}_i &= frac{partial}{partial z^{n_l}_i}J(W,b;x,y) = frac{partial}{partial z^{n_l}_i}frac{1}{2} left|y - h_{W,b}(x) ight|^2 \ &= frac{partial}{partial z^{n_l}_i}frac{1}{2} sum_{j=1}^{S_{n_l}} (y_j-a_j^{(n_l)})^2 = frac{partial}{partial z^{n_l}_i}frac{1}{2} sum_{j=1}^{S_{n_l}} (y_j-f(z_j^{(n_l)}))^2 \ &= - (y_i - f(z_i^{(n_l)})) cdot f'(z^{(n_l)}_i) = - (y_i - a^{(n_l)}_i) cdot f'(z^{(n_l)}_i) end{align}$
]
对 $extstyle l = n_l-1, n_l-2, n_l-3, ldots, 2$ 的各个层，第 $extstyle l$ 层的第 $extstyle i$ 个节点的残差计算方法如下：
$delta^{(l)}_i = left( sum_{j=1}^{s_{l+1}} W^{(l)}_{ji} delta^{(l+1)}_j ight) f'(z^{(l)}_i)$
{译者注：
$egin{align} delta^{(n_l-1)}_i &=frac{partial}{partial z^{n_l-1}_i}J(W,b;x,y) = frac{partial}{partial z^{n_l-1}_i}frac{1}{2} left|y - h_{W,b}(x) ight|^2 = frac{partial}{partial z^{n_l-1}_i}frac{1}{2} sum_{j=1}^{S_{n_l}}(y_j-a_j^{(n_l)})^2 \ &= frac{1}{2} sum_{j=1}^{S_{n_l}}frac{partial}{partial z^{n_l-1}_i}(y_j-a_j^{(n_l)})^2 = frac{1}{2} sum_{j=1}^{S_{n_l}}frac{partial}{partial z^{n_l-1}_i}(y_j-f(z_j^{(n_l)}))^2 \ &= sum_{j=1}^{S_{n_l}}-(y_j-f(z_j^{(n_l)})) cdot frac{partial}{partial z_i^{(n_l-1)}}f(z_j^{(n_l)}) = sum_{j=1}^{S_{n_l}}-(y_j-f(z_j^{(n_l)})) cdot f'(z_j^{(n_l)}) cdot frac{partial z_j^{(n_l)}}{partial z_i^{(n_l-1)}} \ &= sum_{j=1}^{S_{n_l}} delta_j^{(n_l)} cdot frac{partial z_j^{(n_l)}}{partial z_i^{n_l-1}} = sum_{j=1}^{S_{n_l}} left(delta_j^{(n_l)} cdot frac{partial}{partial z_i^{n_l-1}}sum_{k=1}^{S_{n_l-1}}f(z_k^{n_l-1}) cdot W_{jk}^{n_l-1} ight) \ &= sum_{j=1}^{S_{n_l}} delta_j^{(n_l)} cdot W_{ji}^{n_l-1} cdot f'(z_i^{n_l-1}) = left(sum_{j=1}^{S_{n_l}}W_{ji}^{n_l-1}delta_j^{(n_l)} ight)f'(z_i^{n_l-1}) end{align}$
将上式中的 $extstyle n_l-1$ 与 $extstyle n_l$ 的关系替换为 $extstyle l$ 与 $extstyle l+1$ 的关系，就可以得到：
$delta^{(l)}_i = left( sum_{j=1}^{s_{l+1}} W^{(l)}_{ji} delta^{(l+1)}_j ight) f'(z^{(l)}_i)$
以上逐次从后向前求导的过程即为“反向传导”的本意所在。 ]
计算我们需要的偏导数，计算方法如下：
$egin{align} frac{partial}{partial W_{ij}^{(l)}} J(W,b; x, y) &= a^{(l)}_j delta_i^{(l+1)} \ frac{partial}{partial b_{i}^{(l)}} J(W,b; x, y) &= delta_i^{(l+1)}. end{align}$

最后，我们用矩阵-向量表示法重写以上算法。我们使用“ $extstyle ullet$ ” 表示向量乘积运算符（在Matlab或Octave里用“.*”表示，也称作阿达马乘积）。若 $extstyle a = b ullet c$ ，则 $extstyle a_i = b_ic_i$ 。在上一个教程中我们扩展了 $extstyle f(cdot)$ 的定义，使其包含向量运算，这里我们也对偏导数 $extstyle f'(cdot)$ 也做了同样的处理（于是又有 $extstyle f'([z_1, z_2, z_3]) = [f'(z_1), f'(z_2), f'(z_3)]$ ）。

那么，反向传播算法可表示为以下几个步骤：

进行前馈传导计算，利用前向传导公式，得到 $extstyle L_2, L_3, ldots$ 直到输出层 $extstyle L_{n_l}$ 的激活值。
对输出层（第 $extstyle n_l$ 层），计算：
$egin{align} delta^{(n_l)} = - (y - a^{(n_l)}) ullet f'(z^{(n_l)}) end{align}$
对于 $extstyle l = n_l-1, n_l-2, n_l-3, ldots, 2$ 的各层，计算：
$egin{align} delta^{(l)} = left((W^{(l)})^T delta^{(l+1)} ight) ullet f'(z^{(l)}) end{align}$
计算最终需要的偏导数值：
$egin{align} abla_{W^{(l)}} J(W,b;x,y) &= delta^{(l+1)} (a^{(l)})^T, \ abla_{b^{(l)}} J(W,b;x,y) &= delta^{(l+1)}. end{align}$

实现中应注意：在以上的第2步和第3步中，我们需要为每一个 $extstyle i$ 值计算其 $extstyle f'(z^{(l)}_i)$ 。假设 $extstyle f(z)$ 是sigmoid函数，并且我们已经在前向传导运算中得到了 $extstyle a^{(l)}_i$ 。那么，使用我们早先推导出的 $extstyle f'(z)$ 表达式，就可以计算得到 $extstyle f'(z^{(l)}_i) = a^{(l)}_i (1- a^{(l)}_i)$ 。

最后，我们将对梯度下降算法做个全面总结。在下面的伪代码中， $extstyle Delta W^{(l)}$ 是一个与矩阵 $extstyle W^{(l)}$ 维度相同的矩阵， $extstyle Delta b^{(l)}$ 是一个与 $extstyle b^{(l)}$ 维度相同的向量。注意这里“ $extstyle Delta W^{(l)}$ ”是一个矩阵，而不是“ $extstyle Delta$ 与 $extstyle W^{(l)}$ 相乘”。下面，我们实现批量梯度下降法中的一次迭代：

对于所有 $extstyle l$ ，令 $extstyle Delta W^{(l)} := 0$ , $extstyle Delta b^{(l)} := 0$ （设置为全零矩阵或全零向量）
对于到，
1. 使用反向传播算法计算 $extstyle abla_{W^{(l)}} J(W,b;x,y)$ 和 $extstyle abla_{b^{(l)}} J(W,b;x,y)$ 。
2. 计算 $extstyle Delta W^{(l)} := Delta W^{(l)} + abla_{W^{(l)}} J(W,b;x,y)$ 。
3. 计算 $extstyle Delta b^{(l)} := Delta b^{(l)} + abla_{b^{(l)}} J(W,b;x,y)$ 。
更新权重参数：
$egin{align} W^{(l)} &= W^{(l)} - alpha left[ left(frac{1}{m} Delta W^{(l)} ight) + lambda W^{(l)} ight] \ b^{(l)} &= b^{(l)} - alpha left[frac{1}{m} Delta b^{(l)} ight] end{align}$

现在，我们可以重复梯度下降法的迭代步骤来减小代价函数 $extstyle J(W,b)$ 的值，进而求解我们的神经网络

网上的一种反向传播算法的解释（有一些不同）

其他：

http://www.cnblogs.com/wb-DarkHorse/archive/2012/12/12/2815393.html