神经网络反向传播算法及代码实现

反向传播法是神经网络的基础了，但是很多人在学的时候总是会遇到一些问题，或者说看书上一堆推导公式感觉很复杂，其实仔细看，就是一个链式求导法则反复用。本篇会以最详细的方式为大家讲解反向传播法，也会有简单的反向传播代码实现，咱们别急，等我慢慢道来。

1.前向传播

首先我们来看一张简单的两层神经网络图(自己制作的，有点丑)

我先给小伙伴们解释一下图中参数的意思
$x_0$和$y_0$是输入层和隐藏层的偏置值(也可以先不看偏置值)，下面推导默认使用偏置值，只不过b用$w_{0k}{y}_0,v_{0j}{x}_0$表示的，这里面$y_0,x_0$就是b，$w_{0k},v_{0j}$默认为1，
$x_1$，$x_2$…$x_i$…$x_n$是输入的n个特征值，$y_1$，$y_2$…$y_j$…$y_m$是隐藏层经过激活函数后的m个输出值，$o_1$…$o_k$…$o_l$是输出层经过激活函数后的$l$个预测值
$v_{ij}$表示从输入层第i个神经元到隐藏层第j个神经元的权重
$w_{jk}$表示从隐藏层第j个神经元到输出层第k个神经元的权重
了解了这些参数的意思，我们先简单讲解前向传播，这个对小伙伴们来说应该很简单吧！
（1）输入层---->隐藏层：

$ne{t}_j={\sum }_{i=0}^n{v}_{ij}{x}_i$     $j=1,2,3,.....,m$
$ne{t}_j=v_{0j}{x}_0(这就是b)+v_{1j}{x}_1+v_{2j}{x}_2+v_{3j}{x}_3+.....+v_{nj}{x}_n$
$y_j=f(ne{t}_j)$            $j=1,2,3,.....,m$

（2）隐藏层---->输出层：

$ne{t}_k={\sum }_{j=0}^m{w}_{jk}{y}_j$     $k=1,2,3,.....,l$
$ne{t}_k=w_{0k}{y}_0(这就是b)+w_{1k}{y}_1+w_{2k}{y}_2+w_{3k}{y}_3+.....+w_{mk}{y}_m$
$o_k=f(ne{t}_k)$            $k=1,2,3,.....,l$

上面公式中：
$ne{t}_j$和$ne{t}_k$相当于线性回归($Y=WX+B$)的输出结果，$f(x)$是激活函数，这里我们使用$sigmoid$激活函数，也就是$f(x)=\frac{1}{1+e^{-x}}$，$y_j$和$o_k$都是隐藏层和输出层经过激活函数后的结果，最后得到的$o_k$就是正向传播最后得到的预测值。

2.反向传播

接下来我们先定义一个损失函数，最简单也是大家最熟悉的均方差损失函数，也就是$\frac{1}{2}\sum (d-o{)}^2$，这里的$d$就是真实值(标签值),$o$就是上面正向传播得到的预测值，$\frac{1}{2}$是为了求导方便，不影响最后的损失对结果的度量，那么这里的$loss=\frac{1}{2}{\sum }_{k=1}^l(d_k-o_k{)}^2$
又因为：

$y_j=f(ne{t}_j)=f({\sum }_{i=0}^n{v}_{ij}{x}_i)$          $(1.1)$
$o_k=f(ne{t}_k)=f({\sum }_{j=0}^m{w}_{jk}{y}_j)$          $(1.2)$

那么最终的$loss$就等价于：

$loss=\frac{1}{2}{\sum }_{k=1}^l(d_k-o_k{)}^2$             $(1.3)$
   $=\frac{1}{2}{\sum }_{k=1}^l[d_k-f(ne{t}_k){]}^2$
   $=\frac{1}{2}{\sum }_{k=1}^l[d_k-f({\sum }_{j=0}^m{w}_{jk}{y}_j){]}^2$
   $=\frac{1}{2}{\sum }_{k=1}^l[d_k-f({\sum }_{j=0}^m{w}_{jk}f(ne{t}_j)){]}^2$
   $=\frac{1}{2}{\sum }_{k=1}^l[d_k-f({\sum }_{j=0}^m{w}_{jk}f({\sum }_{i=0}^n{v}_{ij}{x}_i)){]}^2$

得到$loss$的完整式子后，我们的目标肯定是$loss$越小越好，这就需要优化$w,v$，用的最多的当然就是梯度下降法了，不停地迭代更新$w,v$，直到得到最合适的$w,v$值使得$loss$最小，由梯度下降法的参数更新公式，可以得到：

$w=w-▽w_{jk}$     $(1.4)$

$v=v-▽v_{ij}$      $(1.5)$

$b_w=b_w-▽b_{0j}$      $(1.6)$

$b_v=b_v-▽b_{0k}$      $(1.7)$

其中$\eta$是学习率，自己设定，那么：

$▽w_{jk}=-\eta \frac{\partial loss}{\partial w_{jk}}=-\eta \frac{\partial loss}{\partial ne{t}_k}\times \frac{\partial ne{t}_k}{\partial w_{jk}}$      $(1.8)$      $\frac{\partial ne{t}_k}{\partial w_{jk}}=y_j$

$▽v_{ij}=-\eta \frac{\partial loss}{\partial v_{ij}}=-\eta \frac{\partial loss}{\partial ne{t}_j}\times \frac{\partial ne{t}_j}{\partial v_{ij}}$       $(1.9)$      $\frac{\partial ne{t}_j}{\partial v_{ij}}=x_i$

我们令:

${\delta }_k^o=-\frac{\partial loss}{\partial ne{t}_k}$       $(2.0)$

${\delta }_j^y=-\frac{\partial loss}{\partial ne{t}_j}$       $(2.1)$

我们把${\delta }_k^o,{\delta }_j^y$称作学习信号，代入式子$(2.0),(2.1)$：

$▽w_{jk}=\eta {\delta }_k^o{y}_j$

$▽v_{ij}=\eta {\delta }_j^y{x}_i$

现在我们来看式子$(2.0),(2.1)$：

${\delta }_k^o=-\frac{\partial loss}{\partial ne{t}_k}=-\frac{\partial loss}{\partial o_k}\times \frac{\partial o_k}{\partial ne{t}_k}=-\frac{\partial loss}{\partial o_k}\times f^{\prime }(ne{t}_k)$

${\delta }_j^y=-\frac{\partial loss}{\partial ne{t}_j}=-\frac{\partial loss}{\partial y_j}\times \frac{\partial y_j}{\partial ne{t}_j}=-\frac{\partial loss}{\partial y_j}\times f^{\prime }(ne{t}_j)$

$\frac{\partial loss}{\partial o_k}=-{\sum }_{k=1}^l(d_k-o_k)$

$\frac{\partial loss}{\partial y_j}=\frac{\partial loss}{\partial o_k}\times \frac{\partial o_k}{\partial ne{t}_k}\times \frac{\partial ne{t}_k}{\partial y_j}=-{\sum }_{k=1}^l(d_k-o_k)\times f^{\prime }(ne{t}_k)\times w_{jk}$

将上面两个式子代回$(2.0),(2.1)$：

$f(x)=\frac{1}{1+e^{-x}}$

$f^{\prime }(x)=f(x)\times (1-f(x))$

${\delta }_k^o={\sum }_{k=1}^l(d_k-o_k)\times f^{\prime }(ne{t}_k)={\sum }_{k=1}^l(d_k-o_k)\times o_k\times (1-o_k)$   (仔细看会发现，这个式子就是损失函数的导数乘上激活函数的导数)                          (2.2)

${\delta }_j^y={\sum }_{k=1}^l(d_k-o_k)\times f^{\prime }(ne{t}_k)\times w_{jk}\times f^{\prime }(ne{t}_j)$
   $={\delta }_k^o\times w_{jk}\times y_j\times (1-y_j)$                           (2.3)

得到了最后的学习信号表达式，就可以代回梯度下降参数更新公式里面了：

$▽w_{jk}=\eta {\delta }_k^o{y}_j=\eta {\sum }_{k=1}^l(d_k-o_k)\times o_k\times (1-o_k)\times y_j$   (2.4)

$▽v_{ij}=\eta {\delta }_j^y{x}_i=\eta {\delta }_k^o\times w_{jk}\times y_j\times (1-y_j)\times x_i$       (2.5)

$w=w-▽w_{jk}$

$v=v-▽v_{ij}$

接下来求$▽b_{0j},▽b_{0k}$，这个比上面的更简单，因为我们知道偏置的权重系数是1，所以就有:

$▽b_{0k}=-\eta \frac{\partial loss}{\partial b_{0k}}=-\eta \frac{\partial loss}{\partial o_k}\times \frac{\partial o_k}{\partial ne{t}_k}\times \frac{\partial ne{t}_k}{\partial b_{0k}}=-{\sum }_{k=1}^l(d_k-o_k)\times f^{\prime }(ne{t}_k)\times 1$                   (2.6)

$▽b_{0j}=-\eta \frac{\partial loss}{\partial b_{0j}}=-\eta \frac{\partial loss}{\partial o_k}\times \frac{\partial o_k}{\partial ne{t}_k}\times \frac{\partial ne{t}_k}{\partial y_j}\times \frac{\partial y_j}{\partial ne{t}_j}\times \frac{\partial ne{t}_j}{\partial b_{0j}}=-{\sum }_{k=1}^l(d_k-o_k)\times f^{\prime }(ne{t}_k)\times w_{jk}\times f^{\prime }(ne{t}_j)\times 1$                         (2.7)

再更新偏置值：

$b_w=b_w-▽b_{0j}$

$b_v=b_v-▽b_{0k}$

这个时候两层的权重和偏置就更新了一次，小伙伴们要要使用其他激活函数或者损失函数，只需要修改对应位置激活函数的导函数和损失函数的导函数就可以了，我们也可以发现参数更新的速度(收敛速度)跟学习率$\eta$有关系，所以lr初始值尽量从小开始设置，上面的推导过程写得很详细，第一次看可能会比较昏，不妨动手跟着算一遍就会很清楚了，矩阵的反向传播也是同样的，过程差不多，大家可以自行推导，下面我将用python代码实现反向传播过程

3.代码实现简单的反向传播

import numpy as np


def sigmoid(x):
    return 1 / (1 + np.exp(-1 * x))


def d_sigmoid(x):
    s = sigmoid(x)
    return s * (np.ones(s.shape) - s)


def mean_square_loss(s, y):
    return np.sum(np.square(s - y) / 2)


def d_mean_square_loss(s, y):
    return s - y


def forward(W1, W2, b1, b2, X, y):
    # 输入层到隐藏层
    y1 = np.matmul(X, W1) + b1  # [2, 3]
    z1 = sigmoid(y1)  # [2, 3]
    # 隐藏层到输出层
    y2 = np.matmul(z1, W2) + b2  # [2, 2]
    z2 = sigmoid(y2)  # [2, 2]
    # 求均方差损失
    loss = mean_square_loss(z2, y)
    return y1, z1, y2, z2, loss


def backward_update(epochs, lr=0.01):
# 随便创的数据和权重，偏置值，小伙伴们也可以使用numpy的ranodm()进行随机初始化
    X = np.array([[0.6, 0.1], [0.3, 0.6]])
    y = np.array([0, 1])
    W1 = np.array([[0.4, 0.3, 0.6], [0.3, 0.4, 0.2]])
    b1 = np.array([0.4, 0.1, 0.2])
    W2 = np.array([[0.2, 0.3], [0.3, 0.4], [0.5, 0.3]])
    b2 = np.array([0.1, 0.2])
    # 先进行一次前向传播
    y1, z1, y2, z2, loss = forward(W1, W2, b1, b2, X, y)
    for i in range(epochs):
        # 求得隐藏层的学习信号(损失函数导数乘激活函数导数)
        ds2 = d_mean_square_loss(z2, y) * d_sigmoid(y2)
        # 根据上面推导结果式子(2.4不看学习率)--->(学习信号乘隐藏层z1的输出结果),注意形状需要转置
        dW2 = np.matmul(z1.T, ds2)
        # 对隐藏层的偏置梯度求和(式子2.6),注意是对列求和
        db2 = np.sum(ds2, axis=0)
        # 式子(2.5)前两个元素相乘
        dx = np.matmul(ds2, W2.T)

        # 对照式子(2.3)
        ds1 = d_sigmoid(y1) * dx
        # 式子(2.5)
        dW1 = np.matmul(X.T, ds1)
        # 对隐藏层的偏置梯度求和(式子2.7),注意是对列求和
        db1 = np.sum(ds1, axis=0)
        # 参数更新
        W1 = W1 - lr * dW1
        b1 = b1 - lr * db1
        W2 = W2 - lr * dW2
        b2 = b2 - lr * db2

        y1, z1, y2, z2, loss = forward(W1, W2, b1, b2, X, y)
        # 每隔100次打印一次损失
        if i % 100 == 0:
            print('第%d批次' % (i / 100))
            print('当前损失为：{:.4f}'.format(loss))
            print(z2)
            # sigmoid激活函数将结果大于0.5的值分为正类，小于0.5的值分为负类
            z2[z2 > 0.5] = 1
            z2[z2 < 0.5] = 0
            print(z2)


if __name__ == '__main__':
    backward_update(epochs=50001, lr=0.01)

训练50000次后，损失差不多收敛也快接近0了，这就是反向传播的代码，小伙伴们多理理上面的推导过程再对应着推导结果来看这个代码就会很清楚了，如果有什么不懂的地方可以留言噢，我会尽快回复的(*￣︶￣)