笔记整理：前向传递与反向传播

前向传递与反向传播

引言

神经网络其实就是一个输入$X$到输出$Y$的映射函数：$f(X)=Y$，函数的系数（权重）就是我们所要训练的网络参数$W$，只要能够确定网络参数$W$，对于任何的输出$x_i$就能得到与之对应的$y_i$。

问题

当我们手中只有训练集的输入$X$和输出$Y$，我们应该如何调整网络参数$W$，使得输出的$f(X)=\hat{Y}$与训练集中的真实值$Y$尽可能接近？

先对反向传播过程有一个直观上的印象。首先，反向传播的核心是cost fuction $J$对网络中参数（各层的权重$W$以及偏置项$b$）的偏导表达式，如下：
$$\frac{\partial J}{\partial w}$$
$$\frac{\partial J}{\partial b}$$
上述的表达式描述了代价函数$J$随权重$W$或偏置$b$变化而变化的程度。

BP算法的思路： 如果当前代价函数所得的数值与真实值相差较远，通过调整$w$和$b$的值，使得新的代价函数所得的预测值更接近真实值。一直重复该过程，直到最终的代价函数所得的预测值与真实值相差在误差范围之内，则停止迭代。

前向传递过程

前向传播过程：已知输入$X$、权重$W$以及偏置$b$，求得输出$Y$。
最普通的DNN可以看作一个多层感知机MLP，$w_{24}^{(3)}$代表神经网络第2层的第4个神经元连接神经网络第3层的第2个神经元的权重。

提问：为什么权重不写成$w_{42}^{(3)}$？
回答：如果写成$w_{42}^{(3)}$，则第3层神经元的输入就要通过$w^{T}x+b$来计算，而当权重为$w_{24}^{(3)}$时，只需要计算$wx+b$，省略了矩阵转置的额外工作量。

偏置项$b$的定义也类似，$b_3^{(2)}$表示神经网络第2层的第3个神经元的偏置。

再定义$a_j^i$和$z_j^i$，分别表示第$i$层神经网络的第$j$个神经元的激活前的输入和激活后的输出，并假设$\sigma (z)$是激活函数。

Sigmoid函数：
$$\sigma (x)=\frac{1}{1+e^{-x}}$$
$${\sigma }^{\prime }(x)=\frac{e^{-x}}{(1+e^{-x}{)}^2}=\frac{1}{1+e^{-x}}\cdot (1-\frac{1}{1+e^{-x}})=\sigma (x)\cdot (1-\sigma (x))$$

举例：
对于第2层第1个节点的输出$a_1^2$有：$a_1^2=\sigma (z_1^2)=\sigma (w_{11}^2{x}_1+w_{12}^2{x}_2+w_{13}^2{x}_3+b_1^2)$
所以一般化，假设$l-1$层有$m$个神经元，对于$a_j^i$有：
$$a_j^l=\sigma (z_j^l)=\sigma (\sum _{k=1}^m{w}_{jk}^l{a}_k^{l-1}+b_j^l)$$

矩阵形式：
$$a^L=\sigma (w^L{a}^{L-1}+b^L)$$

反向传播过程

当通过前向传递得到由任意一组随机参数$W$和$b$计算出的预测结果后，我们可以利用损失函数相对于每个参数的梯度对他们进行修正，从而得到误差范围内的模型，即目标函数$Y$。事实上，神经网络的训练就是这样一个不停的前向-反向传播的过程，直到网络的预测能力达到我们的预期。

反向传播的四个基本方程

根据上述过程描述，权重$w$和偏置$b$的改变如何影响代价函数$J$是理解反向传播的关键，意味着计算出每个$\frac{\partial J}{\partial w_{jk}^l}$和$\frac{\partial J}{\partial b_j^l}$。
在讨论之前，引入误差${\delta }_j^l$，表示第$l$层第$j$个神经元的误差。对于这个误差的理解，《Neural Network and Deep Learning》书中给了一个比较形象的例子。

如上图所示，有一个小恶魔在网络的第$l$层第$j$个神经元捣乱，使得这个神经元发生了变化$\Delta z_j^l$，那么这个神经元在激活后即为$\sigma (z_j^l+\Delta z_j^l)$，然后这个误差向后逐层传播下去，导致最终的代价函数变化了$\frac{\partial J}{\partial z_j^l}{\Delta }_j^l$。然而，小恶魔良心发现，给予我们帮助，使得目标函数$Y$输出的值接近groud truth。选择一个和$\frac{\partial J}{\partial z_j^l}$方向相反的$\Delta z_j^l$，使得损失函数的值更小（梯度下降法）。随着迭代的进行，$\frac{\partial J}{\partial z_j^l}$会逐渐趋向于0，此时有局部最优解了。这就启发我们可以用$\frac{\partial J}{\partial z_j^l}$来衡量神经元的误差：
$${\delta }_j^l=\frac{\partial J}{\partial z_j^l}$$

1. 输出层的误差方程（计算最后一层神经网络产生的误差）

$${\delta }_j^L=\frac{\partial J}{\partial z_j^L}=\frac{\partial J}{\partial a_j^L}\frac{\partial a_j^L}{\partial z_j^L}=\frac{\partial J}{\partial a_j^L}{\sigma }^{\prime }(z_j^L)$$

注释：等式的最右边的第一项，$\frac{\partial J}{\partial a_j^L}$衡量了代价函数随着网络最终输出的变化快慢，而第二项${\sigma }^{\prime }(z_j^L)$则衡量了激活函数输出随$z_j^L$的变化快慢。$L$指最后一层输出层。

矩阵形式：
假设代价函数为$J(w,b,x,y)=\frac{1}{2}{\sum }_{j=1}^m(y_j-a_j^L{)}^2$，则$\frac{\partial J}{\partial a_j^L}=a_j^L-y_i$。
则得到以下公式：
$${\delta }^L={▽}_{a}J\odot {\sigma }^{\prime }(z^L)$$
说明：$\odot$为Hadamard积，即矩阵的点积

2. 误差传递方程（由后往前，计算每一层神经网络产生的误差）

公式：$${\delta }^l=((w^{l+1}{)}^T{\delta }^{l+1})\odot {\sigma }^{\prime }(z^l)$$
由以上公式可得，可以通过第$l+1$层得误差，求得第$l$层的误差，通过结合输出层误差方程和误差传递方程，就可以计算神经网络中任意一层的误差，先计算${\delta }^L$，再计算${\delta }^{L-1}$、${\delta }^{L-2}$、${\delta }^{L-3}$…，直到输入层。

推导过程：
$$\begin{array}{rl}{\delta }_j^l& =\frac{\partial J}{\partial z_j^l}\\ & =\sum _{k=1}^m\frac{\partial J}{\partial z_k^{l+1}}\frac{\partial z_k^{l+1}}{\partial a_j^l}\frac{\partial a_j^l}{\partial z_j^l}\\ & =\sum _{k=1}^m{\delta }_j^{l+1}\cdot \frac{\partial w_{kj}^{l+1}{a}_j^l+b_k^{l+1}}{\partial a_j^l}\cdot {\sigma (z_j^l)}^{\prime }\\ & =\sum _{k=1}^m{\delta }_j^{l+1}\cdot w_{kj}^{l+1}\cdot {\sigma (z_j^l)}^{\prime }\end{array}$$
可以得到以下公式【矩阵形式】
$${\delta }^l=((w^{l+1}{)}^T{\delta }^{l+1})\odot {\sigma }^{\prime }(z^l)$$

3.代价函数对权重的改变率（计算权重的梯度）

$$\frac{\partial J}{\partial w_{jk}^l}=a_k^{l-1}{\delta }_j^l$$
推导过程：
$$\begin{array}{rl}\frac{\partial J}{\partial w_{jk}^l}& =\frac{\partial J}{\partial z_{jk}^l}\cdot \frac{\partial z_{jk}^l}{\partial w_{jk}^l}\\ & ={\delta }_j^l\cdot \frac{\partial (w_{jk}^l{a}_k^{l-1}+b_j^l)}{\partial w_{jk}^l}\\ & =a_k^{l-1}{\delta }_j^l\end{array}$$
可以化简得到下面式子：
$$\frac{\partial J}{\partial w}=a_{in}{\delta }_{out}$$
由上述的公式可得，当上一层激活后的输出接近0的时候，无论返回的误差为多大，$\frac{\partial J}{\partial w}$的改变都很小，这就是解释了为什么神经元饱和不利于训练。当激活前的神经元没有被激活，或者激活后输出神经元处于饱和状态，权重和偏置会学习的非常慢，这不是我们想要的效果。这也说明了为什么我们平时总是说激活函数的选择非常重要。

4. 代价函数对偏置的改变率（计算偏置的梯度）

公式如下：
$$\frac{\partial J}{\partial b_j^l}={\delta }_j^l$$

推导过程：
$$\begin{array}{rl}\frac{\partial J}{\partial b_j^l}& =\frac{\partial J}{\partial z_j^l}\cdot \frac{\partial z_j^l}{\partial b_j^l}\\ & ={\delta }_j^l\cdot \frac{\partial (w_{jk}^l{a}_k^{l-1}+b_j^l)}{\partial b_j^l}\\ & ={\delta }_j^l\end{array}$$

反向传播算法伪代码

• 输入训练集，共有$m$个样本
• 对于训练集中的每个样本$x$，设置输入层（input layer）对应的激活函数$a^l$
• 前向传播：$$a^l=\sigma (z^l)=\sigma (w^l{a}^{l-1}+b^l)$$
• 计算输出层误差：$${\delta }^L={▽}_{a}J\odot {\sigma }^{\prime }(z^L)$$
• 反向传播：$${\delta }^l=((w^{l+1}{)}^T{\delta }^{l+1})\odot {\sigma }^{\prime }(z^l)$$
• 使用梯度下降（gradient descent），优化权重和偏置：
  $$w^l\to w^l-\frac{\eta }{m}\sum _{x=1}^m{\delta }^{x,l}(a^{x,l-1}{)}^T$$
  $$b^l\to b^l-\frac{\eta }{m}\sum _{x=1}^k{\delta }^{x,l}$$

链接：含有实例的BP算法推导

附上代码：

import numpy as np 
import random

def sigmoid_func(x):
    """
    激活函数sigmoid
    """
    return 1/(1 + np.exp(-x))

def sigmoid_derivation(x):
    """
    激活函数的导数
    """
    y = 1/(1 + np.exp(-x))
    
    return y * (1 - y)

def loss_function(output_arry, groud_truth):
    """
    求出与groud truth的损失
    """
    diff = (np.sum((output_arry - groud_truth) ** 2)) / 2
    # print(diff)
    return diff

def backpropagation_func(input_arry, groud_truth, theta):
    """
    反向传播优化权重以及偏置
    input: 
    input_arry --> 输入的矩阵
    groud_truth --> 真实值
    theta ---> 学习率
    
    return: 
    output ---> 输出的值
    """
    # 假定是一个3层的神经网络
    # 假设输入的单个样本的特征向量是1个纬度，共有2个样本，即输入的矩阵为2*1
    # 第2层的有2个神经元，即w的矩阵为2*2
    
    # 前向传递
    w_2 = [[0.15, 0.20], [0.25, 0.30]]
    bias_2 = 0.35
    w_3 = [[0.40, 0.45], [0.50, 0.55]]
    bias_3 = 0.6
    # print(bias_2)
    # print(w_2)

    z_2 = np.dot(w_2, input_arry) + bias_2
    a_2 = sigmoid_func(z_2)
    # print('z2=', z_2)
    # print('a2=', a_2)
    
    z_3 = np.dot(w_3, a_2) + bias_3
    a_3 = sigmoid_func(z_3)
    # print('z3=', z_3)
    # print('a3=', a_3)

    loss = loss_function(a_3, groud_truth)
    print("前向传播的损失为: {}".format(loss))

    for count in range(1000):
        if loss > 0.01:
            # 反向传播
           
            # 输出层的误差(对z的梯度)
            sigmoid_de = sigmoid_derivation(z_3)
            # print('梯度：{}'.format(sigmoid_de))
            #numpy中 * 表示Hadmard乘积
            # print(a_3 - groud_truth)
            
            delta_L = (a_3 - groud_truth) * sigmoid_de
            # print("输出层的误差：{}".format(delta_L))
            

            # 计算第二层的神经元的误差
            # 切记，这里需要将w_3转置，因为上一层的神经元影响下一层的两个神经元
            w_3_transpose = list(np.array(w_3).T)
            delta_l = np.dot(w_3_transpose, delta_L) * sigmoid_derivation(z_2)
            # print("第二层神经元的误差：{}".format(delta_l))
            # print('w_3 = ', w_3[0])
            # print('result = \n', theta * delta_L[0] * a_2)
            # 权重更新
            for i in range(len(w_3)):
                w_3[i] -= theta * delta_L[i] * a_2
            # print("最后一层权重的更新为: {}".format(w_3))
            for i in range(len(w_2)):
                w_2[i] -= theta * delta_l[i] * input_arry
            # print("非最后一层权重更新为:{}".format(w_2))

            # 偏置更新
            bias_3 -= theta * delta_L
            bias_2 -= theta * delta_l
            
            # 再一次进行前向传播
            z_2 = np.dot(w_2, input_arry) + bias_2
            a_2 = sigmoid_func(z_2)
            # print('z2=', z_2)
            # print('a2=', a_2)
            
            z_3 = np.dot(w_3, a_2) + bias_3
            a_3 = sigmoid_func(z_3)
            # print('z3=', z_3)
            # print('a3=', a_3)

            # 反向传播
            loss = loss_function(a_3, groud_truth)
            print("经过反向传播{}次，损失为: {}".format((count+1), loss))
        else:
            break
    
    return w_2, w_3, bias_3, bias_2, loss 

if __name__ == '__main__':
    print("=====反向传播start======")
    theta = 0.5
    input_arry = np.array([0.05, 0.10])
    # print(input_arry)    
    groud_truth = np.array([0.01, 0.99])
    # print(groud_truth.shape)
    # print(input_arry.shape)
    param = backpropagation_func(input_arry, groud_truth, theta)
    print('loss = {}\n'.format(param[4]))
    print('权重w_2 = {}, \n w_3 = {}\n'.format(param[0], param[1]))
    print('偏置bias_2 = {},\n bias_3 = {} \n'.format(param[2], param[3]))

结果：

=====反向传播start======
前向传播的损失为: 0.2983711087600027
经过反向传播1次，损失为: 0.28047144679143016
经过反向传播2次，损失为: 0.2619076230693008
经过反向传播3次，损失为: 0.24293543335380882
经过反向传播4次，损失为: 0.22387321290700182
经过反向传播5次，损失为: 0.20507531776516638
经过反向传播6次，损失为: 0.1868957476561393
......
经过反向传播66次，损失为: 0.010433675583027257
经过反向传播67次，损失为: 0.010230717010390656
经过反向传播68次，损失为: 0.010034748131211645
经过反向传播69次，损失为: 0.009845424426560941
loss = 0.009845424426560941

权重w_2 = [array([0.15686046, 0.21372093]), array([0.25617323, 0.31234645])], 
 w_3 = [array([-0.6641919 , -0.61741066]), array([0.83781677, 0.88865522])]

偏置bias_2 = [-1.18080352  1.16167516],
 bias_3 = [0.48720928 0.47346454]