神经网络

使用步骤

使用神经网络时的步骤：

1. 选择网络结构

   也就是选择多少层以及每层有多少个单元。
   第一层的单元数就是我们训练集的特征数量。最后一层的单元数是我们训练集的结果的类的数量。如果隐藏层数大于1，确保每个隐藏层的单元个数相同，通常情况下隐藏层单元的个数越多越好。我们真正要决定的是隐藏层的层数和每个中间层的单元数。
   

2. 训练神经网络

   1. 参数的随机初始化；
   2. 正向传播计算所有的$h_\theta(x)$；
   3. 计算代价函数$J(\theta)$；
   4. 反向传播计算所有的偏导数；
   5. 数值检验方法检验这些偏导数；
   6. 最小化代价函数。

随机初始化

通常初始参数为正负 $\epsilon$ 之间的随机值。

$\epsilon=\frac{\sqrt6}{\sqrt{L_{in}+L_{out}}}$

正向传播

一个隐藏层示例：

$a^{(1)}=X$
$z^{(2)}=\theta^{(1)}a^{(1)}$
$a^{(2)}=g(z^{(2)})$
$z^{(3)}=\theta^{(2)}a^{(2)}$
$a^{(3)}=g(z^{(3)})$

代价函数

$J(\theta)=-\frac{1}{m}\left[\sum_{i=1}^{m}\sum_{k=1}^{K}y_k^{(i)}\log(h_\theta(x^{(i)}))_k+(1-y_k^{(i)})\log(1-(h_\theta(x^{(i)}))_k)\right]$
$+\frac{\lambda}{2m}\sum_{l=1}^{L-1}\sum_{i=1}^{S_l}\sum_{j=1}^{S_{l+1}}(\theta_{ji}^{(l)})^2$

反向传播

$\delta^{(3)}=a^{(3)}-y$
$\frac{∂}{∂\theta^{(2)}}J(\theta)=(a^{(2)})^T\delta^{(3)}$
$\delta^{(2)}=\delta^{(3)}(\theta^{(2)})^Tg'(z^{(2)})$
$\frac{∂}{∂\theta^{(1)}}J(\theta)=(a^{(1)})^T\delta^{(2)}$
所以，偏导数等于当前层神经元向量 $a^{(l)}$与下一层的误差向量 $\delta^{(l+1)}$相乘。
当前层的误差向量 $\delta^{(l)}$等于下一层的误差向量 $\delta^{(l+1)}$与权重矩阵 $Δ^{(l)}$相乘。

计算梯度：

$D_{ij}^{(l)}=\frac{1}{m}Δ_{ij}^{(l)},j=0$
$D_{ij}^{(l)}=\frac{1}{m}Δ_{ij}^{(l)}+\frac{\lambda}{m}\theta_{ij}^{(l)},j\neq0$

梯度检查

数据梯度检查，根据导数定义

$\frac{d}{d\theta}J(\theta)\approx\frac{J(\theta+\epsilon)-J(\theta-\epsilon)}{2\epsilon}$
梯度计算代价很大，检查完后要关闭梯度检查的代码。

最小化代价函数

在matlab中，可以直接使用fminunc函数计算代价函数的最小值。fminunc函数需要知道代价函数和梯度值。
计算代价函数和梯度的示例代码如下：

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));

%% 对y进行处理 Y(find(y==3))= [0 0 1 0 0 0 0 0 0 0]; 用于 Feedforward cost function 1和2   
Y=[];
E = eye(num_labels);    % 要满足K可以是任意，则不能写eye(10)！！
for i=1:num_labels
    Y0 = find(y==i);    % 找到等于y=i的序列号,替换向量
    Y(Y0,:) = repmat(E(i,:),size(Y0,1),1);
end

%% unregularized Feedforward cost function lambda=0
% % 计算前向传输 Add ones to the X data matrix  -jin
% X = [ones(m, 1) X];
% a2 = sigmoid(X * Theta1');   % 第二层激活函数输出
% a2 = [ones(m, 1) a2];        % 第二层加入b
% a3 = sigmoid(a2 * Theta2');  
% cost = Y .* log(a3) + (1 - Y ) .* log( (1 - a3));  % cost是m*K(5000*10)的结果矩阵  sum(cost(:))全部求和
% J= -1 / m * sum(cost(:));   

%% regularized Feedforward cost function lambda=1
% 计算前向传输 Add ones to the X data matrix  -jin
X = [ones(m, 1) X];
a2 = sigmoid(X * Theta1');   % 第二层激活函数输出
a2 = [ones(m, 1) a2];        % 第二层加入b
a3 = sigmoid(a2 * Theta2');  
temp1 = [zeros(size(Theta1,1),1) Theta1(:,2:end)];   % 先把theta(1)拿掉，不参与正则化
temp2 = [zeros(size(Theta2,1),1) Theta2(:,2:end)];
temp1 = sum(temp1 .^2);     % 计算每个参数的平方，再就求和
temp2 = sum(temp2 .^2);

cost = Y .* log(a3) + (1 - Y ) .* log( (1 - a3));  % cost是m*K(5000*10)的结果矩阵  sum(cost(:))全部求和
J= -1 / m * sum(cost(:)) + lambda/(2*m) * ( sum(temp1(:))+ sum(temp2(:)) );  

%% 计算 Gradient 
delta_1 = zeros(size(Theta1));
delta_2 = zeros(size(Theta2));
for t = 1:m
   % step 1
   a_1 = X(t,:)';          
   % a_1 = [1 ; a_1];
   z_2 = Theta1 * a_1;   
   a_2 = sigmoid(z_2);  
   a_2 = [1 ; a_2];
   z_3 = Theta2 * a_2;
   a_3 = sigmoid(z_3);
   % step 2
   err_3 = zeros(num_labels,1);
   for k = 1:num_labels     
      err_3(k) = a_3(k) - (y(t) == k);
   end
   % step 3
   err_2 = Theta2' * err_3;                % err_2有26行！！！
   err_2 = err_2(2:end) .* sigmoidGradient(z_2);   % 去掉第一个误差值，减少为25. sigmoidGradient(z_2)只有25行！！！
   % step 4
   delta_2 = delta_2 + err_3 * a_2';
   delta_1 = delta_1 + err_2 * a_1';
end
% step 5
Theta1_temp = [zeros(size(Theta1,1),1) Theta1(:,2:end)];
Theta2_temp = [zeros(size(Theta2,1),1) Theta2(:,2:end)];
Theta1_grad = 1 / m * delta_1 + lambda/m * Theta1_temp;
Theta2_grad = 1 / m * delta_2 + lambda/m * Theta2_temp ;

grad = [Theta1_grad(:) ; Theta2_grad(:)];

end