深度学习100问之深入理解Back Propagation（反向传播）

$BackPropagation$(反向传播)算法是多层神经网络的训练中举足轻重的算法。简单的理解，它的确就是复合函数的链式法则，但其在实际运算中的意义比链式法则($chainrule$)要大的多。

机器学习可以看做是数理统计的一个应用，在数理统计中一个常见的任务就是拟合，也就是给定一些样本点，用合适的曲线揭示这些样本点随着自变量的变化关系。

深度学习同样也是为了这个目的，只不过此时，样本点不再限定为$(x，y)$点对，而可以是由向量、矩阵等等组成的广义点对$(X，Y)$。而此时，$(X，Y)$之间的关系也变得十分复杂，不太可能用一个简单函数表示。然而，人们发现可以用多层神经网络表示这样的关系，而多层神经网络的本质就是一个多层复合的函数。

说到神经网络，这个图片应该并不陌生，通过这张图可以比较直观地描绘一下这种复合关系。这是一个典型的三层神经网络，基本构成：$LayerL1$是输入层，$LayerL2$是隐含层，$LayerL3$是输出层，其对应的表达式如下：

上面式中的 $W_{ij}$ 就是相邻两层神经元之间的权值，它们就是深度学习需要学习的参数，也就相当于直线拟合 $y=k\ast x+b$ 中的待求参数$k$和$b$。

和直线拟合一样，深度学习的训练也有一个目标函数，这个目标函数定义了什么样的参数才算一组“好参数”，不过在机器学习中，一般是采用成本函数($costfunction$)，然后，训练目标就是通过调整每一个权值 $W_{ij}$ 来使得 $cost$ 达到最小。$cost$ 函数也可以看成是由所有待求权值 $W_{ij}$ 为自变量的复合函数，而且基本上是非凸的，即含有许多局部最小值。但实际中发现，采用我们常用的梯度下降法就可以有效的求解最小化$cost$函数的问题。

梯度下降法需要给定一个初始点，并求出该点的梯度向量，然后以负梯度方向为搜索方向，以一定的步长进行搜索，从而确定下一个迭代点，再计算该新的梯度方向，如此重复直到 cost 收敛。那么如何计算梯度呢？

假设我们把 cost 函数表示为$H\left(W_{11},W_{12},\cdots ,W_{ij},\cdots ,W_{mn}\right)$，那么它的梯度向量就等于$\nabla H=\frac{\partial H}{\partial W_{11}}{\mathbf{e}}_{11}+\cdots +\frac{\partial H}{\partial W_{mn}}{\mathbf{e}}_{mn}$，其中 eij 表示正交单位向量。为此，我们需求出 cost 函数H对每一个权值 Wij 的偏导数。而BP算法正是用来求解这种多层复合函数的所有变量的偏导数的利器。

我们以求$e=(a+b)\ast (b+1)$的偏导为例。它的复合关系画出图可以表示如下：

在图中，引入了中间变量$c$,$d$。

为了求出$a=2,b=1$时，e的梯度，我们可以先利用偏导数的定义求出不同层之间相邻节点的偏导关系，如下图所示。

利用链式法则我们知道：
$$\frac{\partial e}{\partial a}=\frac{\partial e}{\partial c}\cdot \frac{\partial c}{\partial a}$$
$$\frac{\partial e}{\partial b}=\frac{\partial e}{\partial c}\cdot \frac{\partial c}{\partial b}+\frac{\partial e}{\partial d}\cdot \frac{\partial d}{\partial b}$$
链式法则在上图中的意义是什么呢？其实不难发现，$\frac{\partial e}{\partial a}$的值等于从$a$到$e$的路径上的偏导值的乘积，而$\frac{\partial e}{\partial b}$的值等于从$b$到$e$的路径$1(b-c-e)$上的偏导值的乘积加上路径$2(b-d-e)$上的偏导值的乘积。也就是说，对于上层节点$p$和下层节点$q$，要求得$\frac{\partial p}{\partial q}$，需要找到从$q$节点到$p$节点的所有路径，并且对每条路径，求得该路径上的所有偏导数之乘积，然后将所有路径的 “乘积” 累加起来才能得到$\frac{\partial p}{\partial q}$的值。

大家也许已经注意到，这样做是十分冗余的，因为很多路径被重复访问了。比如上图中，$a-c-e$和$b-c-e$就都走了路径$c-e$。对于权值动则数万的深度模型中的神经网络，这样的冗余所导致的计算量是相当大的。

同样是利用链式法则，$BP$算法则机智地避开了这种冗余，它对于每一个路径只访问一次就能求顶点对所有下层节点的偏导值。

正如反向传播($BP$)算法的名字说的那样，$BP$算法是反向(自上往下)来寻找路径的。

从最上层的节点$e$开始，初始值为1，以层为单位进行处理。对于e的下一层的所有子节点，将1乘以$e$到某个节点路径上的偏导值，并将结果“堆放”在该子节点中。等$e$所在的层按照这样传播完毕后，第二层的每一个节点都“堆放"些值，然后我们针对每个节点，把它里面所有“堆放”的值求和，就得到了顶点$e$对该节点的偏导。然后将这些第二层的节点各自作为起始顶点，初始值设为顶点$e$对它们的偏导值，以"层"为单位重复上述传播过程，即可求出顶点$e$对每一层节点的偏导数。

以上图为例，节点$c$接受$e$发送的1 * 2并堆放起来，节点$d$接受$e$发送的1 * 3并堆放起来，至此第二层完毕，求出各节点总堆放量并继续向下一层发送。节点$c$向$a$发送2 * 1并对堆放起来，节点$c$向$b$发送2 * 1并堆放起来，节点$d$向$b$发送3 * 1并堆放起来，至此第三层完毕，节点$a$堆放起来的量为2，节点$b$堆放起来的量为2 * 1+3 * 1=5, 即顶点$e$对$b$的偏导数为5。

假设，你有这样一个网络层：

通过对所有参数：输入数据，输出数据，初始权重，进行赋值。

输入数据：i1=0.05，i2=0.10；
输出数据：o1=0.01，o2=0.99；
第一层的初始权重：w1=0.15，w2=0.20，w3=0.25，w4=0.30；
第二层的初始权重：w5=0.40，w6=0.45，w7=0.50，w8=0.55；
初始偏置：b1=0.35，b2=0.60；

目标：给出输入数据$i1$，$i2$(0.05和0.10)，使输出尽可能与原始输出$o1$,$o2$(0.01和0.99)接近。
先进行前向传播，然后反向传播进而更新参数。

反向传播时计算总误差($squareerror$)：
$$E_{\text{total}}=\sum \frac{1}{2}(\text{target}-\text{ output }{)}^2$$
有两个输出，所以分别计算$o1$和$o2$的误差，总误差为两者之和：
$$E_{total}=E_{o1}+E_{o2}$$
以$w5$和$w1$为例：

$$w_5^{+}=w_5-\eta \ast \frac{\partial E_{total}}{\partial w_5}$$
计算总误差对$w5$的偏导时，是从$out(o1)---->net(o1)---->w5$，但是在隐含层之间的权值更新时，是$out(h1)---->net(h1)---->w1$,而$out(h1)$会接受$E(o1)$和$E(o2)$两个地方传来的误差，所以这个地方两个都要计算。

$$w_1^{+}=w_1-\eta \ast \frac{\partial E_{total}}{\partial w_1}$$
这样一次误差的反向传播法就完成了，最后我们再把更新的权值重新计算，然后不停地迭代这个过程。

代码：

import random
import math#   参数解释：
#   "pd_" ：偏导的前缀
#   "d_" ：导数的前缀
#   "w_ho" ：隐含层到输出层的权重系数索引
#   "w_ih" ：输入层到隐含层的权重系数的索引class NeuralNetwork:LEARNING_RATE = 0.5def __init__(self, num_inputs, num_hidden, num_outputs, hidden_layer_weights = None, hidden_layer_bias = None, output_layer_weights = None, output_layer_bias = None):self.num_inputs = num_inputsself.hidden_layer = NeuronLayer(num_hidden, hidden_layer_bias)self.output_layer = NeuronLayer(num_outputs, output_layer_bias)self.init_weights_from_inputs_to_hidden_layer_neurons(hidden_layer_weights)self.init_weights_from_hidden_layer_neurons_to_output_layer_neurons(output_layer_weights)def init_weights_from_inputs_to_hidden_layer_neurons(self, hidden_layer_weights):weight_num = 0for h in range(len(self.hidden_layer.neurons)):for i in range(self.num_inputs):if not hidden_layer_weights:self.hidden_layer.neurons[h].weights.append(random.random())else:self.hidden_layer.neurons[h].weights.append(hidden_layer_weights[weight_num])weight_num += 1def init_weights_from_hidden_layer_neurons_to_output_layer_neurons(self, output_layer_weights):weight_num = 0for o in range(len(self.output_layer.neurons)):for h in range(len(self.hidden_layer.neurons)):if not output_layer_weights:self.output_layer.neurons[o].weights.append(random.random())else:self.output_layer.neurons[o].weights.append(output_layer_weights[weight_num])weight_num += 1def inspect(self):print('------')print('* Inputs: {}'.format(self.num_inputs))print('------')print('Hidden Layer')self.hidden_layer.inspect()print('------')print('* Output Layer')self.output_layer.inspect()print('------')def feed_forward(self, inputs):hidden_layer_outputs = self.hidden_layer.feed_forward(inputs)return self.output_layer.feed_forward(hidden_layer_outputs)def train(self, training_inputs, training_outputs):self.feed_forward(training_inputs)# 1. 输出神经元的值pd_errors_wrt_output_neuron_total_net_input = [0] * len(self.output_layer.neurons)for o in range(len(self.output_layer.neurons)):# ∂E/∂zⱼpd_errors_wrt_output_neuron_total_net_input[o] = self.output_layer.neurons[o].calculate_pd_error_wrt_total_net_input(training_outputs[o])# 2. 隐含层神经元的值pd_errors_wrt_hidden_neuron_total_net_input = [0] * len(self.hidden_layer.neurons)for h in range(len(self.hidden_layer.neurons)):# dE/dyⱼ = Σ ∂E/∂zⱼ * ∂z/∂yⱼ = Σ ∂E/∂zⱼ * wᵢⱼd_error_wrt_hidden_neuron_output = 0for o in range(len(self.output_layer.neurons)):d_error_wrt_hidden_neuron_output += pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].weights[h]# ∂E/∂zⱼ = dE/dyⱼ * ∂zⱼ/∂pd_errors_wrt_hidden_neuron_total_net_input[h] = d_error_wrt_hidden_neuron_output * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_input()# 3. 更新输出层权重系数for o in range(len(self.output_layer.neurons)):for w_ho in range(len(self.output_layer.neurons[o].weights)):# ∂Eⱼ/∂wᵢⱼ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢⱼpd_error_wrt_weight = pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].calculate_pd_total_net_input_wrt_weight(w_ho)# Δw = α * ∂Eⱼ/∂wᵢself.output_layer.neurons[o].weights[w_ho] -= self.LEARNING_RATE * pd_error_wrt_weight# 4. 更新隐含层的权重系数for h in range(len(self.hidden_layer.neurons)):for w_ih in range(len(self.hidden_layer.neurons[h].weights)):# ∂Eⱼ/∂wᵢ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢpd_error_wrt_weight = pd_errors_wrt_hidden_neuron_total_net_input[h] * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_weight(w_ih)# Δw = α * ∂Eⱼ/∂wᵢself.hidden_layer.neurons[h].weights[w_ih] -= self.LEARNING_RATE * pd_error_wrt_weightdef calculate_total_error(self, training_sets):total_error = 0for t in range(len(training_sets)):training_inputs, training_outputs = training_sets[t]self.feed_forward(training_inputs)for o in range(len(training_outputs)):total_error += self.output_layer.neurons[o].calculate_error(training_outputs[o])return total_errorclass NeuronLayer:def __init__(self, num_neurons, bias):# 同一层的神经元共享一个截距项bself.bias = bias if bias else random.random()self.neurons = []for i in range(num_neurons):self.neurons.append(Neuron(self.bias))def inspect(self):print('Neurons:', len(self.neurons))for n in range(len(self.neurons)):print(' Neuron', n)for w in range(len(self.neurons[n].weights)):print('  Weight:', self.neurons[n].weights[w])print('  Bias:', self.bias)def feed_forward(self, inputs):outputs = []for neuron in self.neurons:outputs.append(neuron.calculate_output(inputs))return outputsdef get_outputs(self):outputs = []for neuron in self.neurons:outputs.append(neuron.output)return outputsclass Neuron:def __init__(self, bias):self.bias = biasself.weights = []def calculate_output(self, inputs):self.inputs = inputsself.output = self.squash(self.calculate_total_net_input())return self.outputdef calculate_total_net_input(self):total = 0for i in range(len(self.inputs)):total += self.inputs[i] * self.weights[i]return total + self.bias# 激活函数sigmoiddef squash(self, total_net_input):return 1 / (1 + math.exp(-total_net_input))def calculate_pd_error_wrt_total_net_input(self, target_output):return self.calculate_pd_error_wrt_output(target_output) * self.calculate_pd_total_net_input_wrt_input();# 每一个神经元的误差是由平方差公式计算的def calculate_error(self, target_output):return 0.5 * (target_output - self.output) ** 2def calculate_pd_error_wrt_output(self, target_output):return -(target_output - self.output)def calculate_pd_total_net_input_wrt_input(self):return self.output * (1 - self.output)def calculate_pd_total_net_input_wrt_weight(self, index):return self.inputs[index]# 文中的例子:nn = NeuralNetwork(2, 2, 2, hidden_layer_weights=[0.15, 0.2, 0.25, 0.3], hidden_layer_bias=0.35, output_layer_weights=[0.4, 0.45, 0.5, 0.55], output_layer_bias=0.6)
for i in range(10000):nn.train([0.05, 0.1], [0.01, 0.09])print(i, round(nn.calculate_total_error([[[0.05, 0.1], [0.01, 0.09]]]), 9))#另外一个例子，可以把上面的例子注释掉再运行一下:# training_sets = [
#     [[0, 0], [0]],
#     [[0, 1], [1]],
#     [[1, 0], [1]],
#     [[1, 1], [0]]
# ]# nn = NeuralNetwork(len(training_sets[0][0]), 5, len(training_sets[0][1]))
# for i in range(10000):
#     training_inputs, training_outputs = random.choice(training_sets)
#     nn.train(training_inputs, training_outputs)
#     print(i, nn.calculate_total_error(training_sets))

假设，使用了一个具有两个输入，两个隐藏层和一个输出的三层神经网络，如下图所示：

每个神经元由两个单元组成。第一单元添加权重系数和输入信号的乘积。第二个单元实现非线性功能，称为神经元激活功能。信号$e$是加法器输出信号，$y=f(e)$是非线性元件的输出信号。信号$y$也是神经元的输出信号。

为了让神经网络学习，我们需要训练数据集。训练数据集由输入信号($x_1$和$x_2$)组成，而输入信号分配有相应目标(期望的输出)$z$。网络训练是一个迭代过程，在每次迭代中，使用训练数据集中的新数据来修改节点的权重系数。

使用下面描述的算法计算修改：每一个学习步骤都是从训练集中的两个输入信号开始的。在此阶段之后，我们可以确定每个网络层中每个神经元的输出信号值。下面的图片说明了信号如何通过网络传播，符号$W_{(Xm)n}$表示网络输入之间的连接权重$x_m$和输入层中的神经元$n$。符号$y_n$表示神经元$n$的输出信号。



通过隐藏层传播信号，符号$w_{mn}$代表下一层中神经元m的输出和神经元n的输入之间的连接权重


通过输出层传播信号。

在下一个算法步骤中，将网络y的输出信号与在训练数据集中找到的期望输出值(目标)进行比较。差异称为输出层神经元的误差信号$\delta$。

由于内部神经元的输出值是未知的，直接计算内部神经元的误差信号是不可能的。多年来，训练多层网络的有效方法一直是未知的。直到80年代中期，反向传播算法才被提出。其思想是将误差信号$\delta$(在单独的教学步骤中计算)传播回所有神经元，输出信号作为讨论神经元的输入。


用于传播误差的权值系数$w_{mn}$等于计算输出值时使用的权值系数$w_{mn}$。只改变数据流的方向(信号一个接一个地从输出传播到输入)。此技术适用于所有网络层。如果传播的误差来自少数神经元，则添加误差。下图:



当计算每个神经元的误差信号时，可以修改每个神经元输入节点的权系数。式$\frac{df(e)}{de}$表示神经元激活函数的导数(修改权值)。






系数$\eta$影响网络学习速度。有一些技术可以选择这个参数。第一种方法是用较大的参数值开始学习过程。在建立权重系数的同时，参数逐渐减小。第二种方法更为复杂，它以较小的参数值开始学习。在学习过程中，随着学习的推进，参数逐渐增大，在最后阶段又逐渐减小。以较低的参数值开始学习过程，可以确定权重系数符号。