手撸反向传播算法(附代码)

引言

根据上篇文章介绍的反向传播算法理论，我们今天来手动计算一下。

我们简化下上篇文章中的NN模型（参数和它类似，这里把每个偏差值设成1），使它的隐藏层只有1层。它有两个输入和两个输出。

我们有初始化权重、偏差和训练用的输入和输出值。

反向传播算法的目的是优化权值$w$来最小化损失函数，从而使NN预测的输出和实际输出更匹配。

假设给定一个训练集，它的输入是$1,-1$，我们想要NN输出$0.00$和$0.99$

正向过程(Forward Pass)

首先我们看看这个NN在初始权值和训练数据下的表现。我们会计算出每个隐藏神经元的输入，通过激活函数(这里用​​Sigmoid​​函数)转换成下一层的输入，直到达到输出层计算出最终输出。

先来计算隐藏层$h_1$的输入，
$z_{h_1} = w_1x_1 + w_2x_2 + 1 = 1 * 1 + (-2) * (-1) + 1 = 4$

然后将它代入激活函数(这里用​​Sigmoid​​​函数)，得到隐藏层$h_1$的输出，

$a_{h_1} = \sigma(z_{h_1}) = \frac{1}{1+e^{-z_{h_1}}} = \frac{1}{1+e^{-4}} = 0.98201379$，

同理有

$z_{h_2} = w_3x_1 + w_4x_2 + 1 = (-1) * 1 + 1 * (-1) + 1 = -1$

可得$a_{h_2} = \sigma(z_{h_2}) =0.26894142$

这两个输出又可作为它们的下一层的输入，计算输出层$o_1$的输出如下两个步骤：

$z_{o_1} = w_5 * a_{h_1} + w_6 * a_{h_2} + 1 =2 * 0.98201379 + (-2) * 0.26894142 + 1 = 2.42614474$

$a_{o_1} = \sigma(z_{o_1}) = \frac{1}{1+e^{-z_{o_1}}} = \frac{1}{1+e^{-2.42614474}} = 0.91879937$

输出层$o_2$的输出也是同理：

$z_{o_2} = w_7 * \sigma(z_{h_1}) + w_8 * \sigma(z_{h_2}) + 1 =(-2) * 0.98201379 + (-1) * 0.26894142 + 1 = -1.23296900$

$a_{o_2} = \sigma(z_{o_2}) = \frac{1}{1+e^{-z_{o_2}}} = \frac{1}{1+e^{-2.42614474}} = 0.22566220$

可以看到，在初始参数上的输出和我们的目标$0.01,0.99$还是有不小距离的。

接下来，我们计算这不小距离到底有多么不小。

计算总误差(Total Error)

我们使用均方误差来计算总误差：

$E_{total} = \frac{1}{2} \sum (\hat{y} - y) ^ 2$

其中$y$就是输出层的实际输出，而$\hat{y}$则是它的期望输出。

比如$o_1$神经元的期望输出是$0.01$，但是实际输出是$0.91879937$，所以误差是：

$E_{o_1} = \frac{1}{2}(\hat{y_{o_1}} - y_{o_1})^2 = \frac{1}{2}(0.01 - 0.91879937)^2 = 0.41295815$

使用同样的过程计算出$E_{o_2}$:

$E_{o_2} = 0.29210614$

总误差就是这些误差之和：

$E_{total} = E_{o_1} + E_{o_2} = 0.41295815 + 0.29210614= 0.70506429$

这个距离是真的不小啊。

反向过程

反向传播算法的目的是更高效的计算梯度，从而更新参数值，使得总误差更小，也就是使实际输出更贴近我们期望输出。它是作为一个整体去更新整个神经网络的。
反向就是先考虑输出层，然后再考虑它的上一层，并重复这个过程。因此，我们先从输出层开始计算。

输出层

考虑参数$w_5$，我们想知道$w_5$的改变会对总误差有多大的影响，即计算
$\frac{E_{total}}{\partial w_5}$。

$\frac{E_{total}}{\partial w_5} = \frac{\partial E_{total}}{\partial a_{o_1}} \frac{\partial a_{o_1}}{\partial z_{o_1}} \frac{\partial z_{o_1}}{\partial w_5}$

我们需要计算这个等式中的每个式子，首先计算$a_{o_1}$如何影响总误差

$E_{total} = \frac{1}{2} \sum (target_{o_1 - z_{o_1}}) ^ 2 + \frac{1}{2}(target_{o_2} - z_{o_2})^2$
$\frac{\partial E_{total}}{\partial a_{o_1}} = 2 * \frac{1}{2}(target_{o_1 - z_{o_1}}) * (-1) + 0 = -(target_{o_1} - a_{o_1} ) = -(0.01-0.91879937) = 0.90879937$

接下来计算$\frac{\partial a_{o_1}}{\partial z_{o_1}}$

我们知道$\sigma^\prime(z)=\sigma(z)(1-\sigma(z))$

所以 $\frac{\partial a_{o_1}}{\partial z_{o_1}} = a_{o_1}(1-a_{o_1} ) = 0.91879937(1-0.91879937) = 0.07460709$

最后是最简单的$\frac{\partial z_{o_1}}{\partial w_5}$

$z_{o_1} = w_5 a_{h_1} + w_6 a_{h_2} + b$
$\frac{\partial z_{o_1}}{\partial w_5} = a_{h_1} = 0.98201379$

最后放到一起得：

$\frac{E_{total}}{\partial w_5} = \frac{\partial E_{total}}{\partial a_{o_1}} \frac{\partial a_{o_1}}{\partial z_{o_1}} \frac{\partial z_{o_1}}{\partial w_5} = 0.90879937 * 0.07460709 * 0.98201379 = 0.06658336$

通常一般定义 $\delta_{o_1} = \frac{\partial E_{total}}{\partial a_{o_1}} \frac{\partial a_{o_1}}{\partial z_{o_1}} = \frac{\partial E_{total}}{\partial z_{o_1}}$
因此 $\frac{\partial E_{total}}{\partial w_5} = \delta_{o_1} z_{h_1}$

为了减少误差，通常需要减少当前权值，如下：

$w_5^+ = w_5 - \alpha * \frac{\partial E_{total}}{\partial w_5} = 2 - 0.5 * 0.06658336 = 1.96670832$

学习率$\alpha$一般取值$0.5$，当然是需要根据实际情况去调整的。

同理可算得$w_6,w_7,w_8$:
$w_6^+ = -2.00911750$
$w_7^+ = -1.93442139$
$w_8^+ = -0.98204017$

但还未结束，我们只是更新了输出层的参数，还要继续往前，更新隐藏层的参数。

隐藏层

首先来更新$w_1$:
$\frac{E_{total}}{\partial w_1} = \frac{\partial E_{total}}{\partial a_{h_1}} \frac{\partial a_{h_1}}{\partial z_{h_1}} \frac{\partial z_{h_1}}{\partial w_1}$

我们要用和更新输出层参数类似的步骤来更新隐藏层的参数，但有一点不同的是，每个隐藏层的神经元都影响了多个输出层(或下一层)神经元的输出。$a_{h_1}$同时影响了$a_{o_1}$和$a_{o_2}$，因此计算$\frac{\partial E_{total}}{\partial a_{h_1}}$需要将输出层的两个神经元都考虑在内：

$\frac{E_{total}}{\partial a_{h_1}} = \frac{\partial E_{o_1}}{\partial a_{h_1}} + \frac{\partial E_{o_2}}{\partial a_{h_1}}$

从$\frac{\partial E_{o_1}}{\partial a_{h_1}}$开始:

$\frac{\partial E_{o_1}}{\partial a_{h_1}} = \frac{\partial E_{o_1}}{\partial {z_{o_1}}} * \frac{\partial z_{o_1}}{\partial {a_{h_1}}}$

其实我们上面已经算过$\frac{\partial E_{o_1}}{\partial {z_{o_1}}}$了：

$\frac{\partial E_{o_1}}{\partial {z_{o_1}}} = \frac{\partial E_{o_1}}{\partial {a_{o_1}}} * \frac{\partial a_{o_1}}{\partial {z_{o_1}}} = 0.90879937 * 0.07460709 = 0.06780288$

并且$\frac{\partial z_{o_1}}{\partial {a_{h_1}}}=w_5$:

$z_{o_1} = w_5a_{h_1} + w_6a_{h_2} + b*1$
$\frac{\partial z_{o_1}}{\partial {a_{h_1}}}=w_5=2$

也就是：

$\frac{\partial E_{o_1}}{\partial a_{h_1}} = \frac{\partial E_{o_1}}{\partial {z_{o_1}}} * \frac{\partial z_{o_1}}{\partial {a_{h_1}}} = 0.06780288*2=0.13560576$

同理，可得$\frac{\partial E_{o_2}}{\partial a_{h_1}}=-0.13355945 * (-2) = 0.26711890$

因此：

$\frac{E_{total}}{\partial a_{h_1}} = \frac{\partial E_{o_1}}{\partial a_{h_1}} + \frac{\partial E_{o_2}}{\partial a_{h_1}} = 0.13560576 + 0.26711890 = 0.40272466$

现在我们已经知道了$\frac{E_{total}}{\partial a_{h_1}}$，我们还需要计算$\frac{\partial a_{h_1}}{\partial z_{h_1}}$和 $\frac{\partial z_{h_1}}{\partial w_1}$:

$a_{h_1}= \frac{1}{1+e^{-z{h_1}}}=\frac{1}{1+e^{-4{}}}=0.98201379$
$\frac{\partial a_{h_1}}{\partial z_{h_1}}=a_{h_1}(1-a_{h_1})=0.98201379(1-0.98201379)=0.01766271$

$z_{h_1} = w_1x_1 + w_2x_2 + b$

$\frac{\partial z_{h_1}}{\partial w_1}=x_1=1$

最后，总式子就可以计算了：

$\frac{E_{total}}{\partial w_1} = \frac{\partial E_{total}}{\partial a_{h_1}} \frac{\partial a_{h_1}}{\partial z_{h_1}} \frac{\partial z_{h_1}}{\partial w_1} = 0.40272466 * 0.01766271 * 1 = 0.00711321$

接下来，就可以更新$w_1$了：

$w_1^+=w_1 - \alpha * \frac{E_{total}}{\partial w_1}=0.99644340$

同理算得$w_2,w_3,w_4$:

$w_2^+=-1.99644340$
$w_3^+=-0.99979884$
$w_4^+=0.99979884$

终于，我们更新完一轮权值了！接下来用原始输入值来测试更新权值后的总误差是多少？经计算误差是：$0.705$ 还记得未更新前的总误差吗？ $0.70506429$

但是在我们执行10000次更新权值的过程后：

>times=9999, lrate=0.500, error=0.000
[0.011851540581436764, 0.9878060737917571]

总误差成了$0.000$，输出是$0.011851540581436764$和$0.9878060737917571$

和期望输出$0.01$以及$0.99$比是不是十分接近了。

(上面同理计算可得的地方其实我都是用代码算的，下面就贴出代码)

反向传播代码

# -*- coding: utf-8 -*
from math import exp


# 计算z
def calculate_z(weights, inputs):
    z = weights[-1]  # 偏差b  # z = x₁w₁ + x₂w₂ + ... + b
    for i in range(len(weights) - 1):
        z += weights[i] * inputs[i]
    return z


# 激活函数Sigmoid:  σ(z) =  1 / (1 + e^(-z))
def active(z):
    return 1.0 / (1.0 + exp(-z))


# 正向传播过程
def forward_pass(network, row):
    inputs = row
    for layer in network:
        new_inputs = []
        for neuron in layer:
            z = calculate_z(neuron['weights'], inputs)  # 计算z
            neuron['output'] = active(z)  # 代入激活函数得到输出 并保存到 output key中
            new_inputs.append(neuron['output'])
        inputs = new_inputs
    return inputs


# sigmoid函数的导数 : 𝑑σ/𝑑z = σ(1-σ)
def active_derivative(output):
    return output * (1.0 - output)


# 反向传播过程
def back_pass(network, expected):
    for i in reversed(range(len(network))):
        layer = network[i]  # 从输出层开始
        errors = []
        if i != len(network) - 1:  # 如果非输出层
            for j in range(len(layer)):  # 遍历所有神经元
                error = 0.0
                # 计算 ∂Etotal/∂a = ∂Eo₁/∂ah₁ + ∂Eo₂/∂ah₁ ...
                for neuron in network[i + 1]:  # 下一层的神经元
                    error += (neuron['weights'][j] * neuron['delta'])  # 反向传播
                errors.append(error)
        else:  # 如果是输出层
            for j in range(len(layer)):
                neuron = layer[j]  # 遍历输出的神经元
                errors.append(neuron['output'] - expected[j])  # -(target - output) 计算∂E/∂a

        for j in range(len(layer)):
            neuron = layer[j]
            neuron['delta'] = errors[j] * active_derivative(neuron['output'])  # δ = ∂E/∂zⱼ = ∂E/∂yⱼ * daⱼ/dzⱼ


# 更新参数
def update_weights(network, row, l_rate):
    for i in range(len(network)):
        inputs = row[:-1]  # 去掉数据集中最后的类别标签
        if i != 0:
            inputs = [neuron['output'] for neuron in network[i - 1]]  # 如果不是输入层，则更新该层的输入为上一层的输出
        for neuron in network[i]:
            for j in range(len(inputs)):  # 入参的数量也就是权值参数的数量
                neuron['weights'][j] -= l_rate * neuron['delta'] * inputs[j]  # wⱼ  = wⱼ  - α * δ * xⱼ
                neuron['weights'][-1] -= l_rate * neuron['delta'] * 1  # 同时更新了偏差b,如果更新了偏差，结果会更好


def total_error(outputs, expected):
    sum_error = 0.0
    for i in range(len(expected)):
        sum_error += (expected[i] - outputs[i]) ** 2
    return sum_error / 2.0


def test():
    network = [[{'weights': [1, -2, 1]},
                {'weights': [-1, 1, 1]}],
               [{'weights': [2, -2, 1]},
                {'weights': [-2, -1, 1]}]]

    dataset = [[1, -1, None]]
    n_inputs = len(dataset[0]) - 1
    expected = [0.01, 0.99]
    l_rate = 0.5

    for times in range(10000):
        sum_error = 0.0
        for row in dataset:
            outputs = forward_pass(network, row)
            sum_error += total_error(outputs, expected)
            back_pass(network, expected)
            update_weights(network, row, l_rate)
        print('>times=%d, lrate=%.3f, error=%.3f' % (times, l_rate, sum_error))

    outputs = forward_pass(network, dataset[0])
    print(outputs)


if __name__ == '__main__':
    test()

有任何问题欢迎留言探讨。

参考

1. 深度学习入门之反向传播算法
2. ​​a-step-by-step-backpropagation-example​​
3. ​​李宏毅 深度学习​​