深度学习系列二：反向传播算法解析与简单示例

概述

上一章主要描述了线性回归与逻辑回归的概念与区别，在模型优化方面带过了，本篇着重记录下深度学习中常用来作参数优化的反向传播算法，并结合一个简单的例子阐明。
首先需要明确的是，任何一个神经网络都可以看作是一个关于其输入的函数，这个函数接受一系列值作为其输入，并输出一个或者多个结果，如下：
$$(y_0,y_1...y_m)=f(x_1,x_2...x_n)$$
简化为向量形式：
$$Y=f(X)$$
其中m，n均可以为1或者任意值，此外，此函数中还包含一系列参数用于调整该模型的性能，因此该函数可以写成如下形式：
$$(y_0,y_1...y_m)=f_{w_1,w_2...w_k}(x_1,x_2...x_n)$$
简化形式：
$$Y=f(X,W)$$
例如常用的线性模型：
$$Y=WX+B$$
因此，可以认为任意网络都仅由三个要素组成：输入、输出、参数。一般而言，输入是采集到的数据例如图像、语音等等，转化为数据作为输入，经过网络中与网络参数一系列的计算得到输出，显然一个未经训练的网络输出只是一系列没有规律的值，而网络训练的过程，实际就是采集一系列已知的输入和输出真值，将输入喂入网络，生成一个输出，并将网络的输出与采集的输出真值对比，以其差值在网络中进行反向传播来优化网络参数的过程。

实现

• 损失函数
  损失函数的作用就是衡量网络输出与输出真值的差距，可以认为，当该差距越小时，网络输出与输出真值越接近，也越能够反应该组数据的规律，不同的网络会因为各种原因选用不同的损失函数，这里不做深入探究，损失函数可以简化如下：
  $$loss=C(f_{w_1,w_2...w_k}(x_1,x_2...x_n),y_{truth})$$
  简化：
  $$loss=C(f(X,W),Y_{truth})$$
• 梯度下降
  因此可以认为网络训练的过程就是调整参数使loss不断趋于极小值的过程，有许多算法可以实现，这里主要介绍下常用的梯度下降法，其细节也有很多文章讲解，这里也不多作介绍，对于以上loss函数，在训练过程中，由于输入$x_1,x_2...x_n$与$y_{truth}$为提前采集到的数据，可以认为是已知值，将参数$w_1,w_2...w_k$视为自变量，loss为因变量，其梯度如下：
  $$(\frac{\partial C}{\partial w_1},\frac{\partial C}{\partial w_2},...\frac{\partial C}{\partial w_k})$$
  加入学习率如下：
  $$(\Delta w_1,\Delta w_2...\Delta w_k,)=\eta (\frac{\partial C}{\partial w_1},\frac{\partial C}{\partial w_2},...\frac{\partial C}{\partial w_k})$$
  因此，参数优化如下：
  $$\begin{gathered} w_1^{\prime }=w_1-\Delta w_1 \\ {w}_2^{\prime }=w_2-\Delta w_2 \\ ... \\ {w}_k^{\prime }=w_1-\Delta w_k \end{gathered}$$

简单示例与代码

以一个简单逻辑回归为例，其网络结构如下：

表达式如下：
$$\begin{gathered} Z^1=W_1{X}_1+B_1 \\ {Z}^2=W_2{Z}^1+B_2 \end{gathered}$$
其激活函数为sigmoid:
$$\sigma (z)=\frac{1}{1+e^{-z}}$$
$$a=\sigma (z_1^2)$$
使用交叉熵作为损失函数：
$$C=y_{label}log(a)+(1-y_{label})log(1-a)$$
于是有：
$$\begin{gathered} \frac{\partial C}{\partial a}=\frac{y_{label}}{a}-\frac{1-y_{label}}{1-a} \\ \frac{\partial a}{\partial z_1^2}=a(1-a) \\ \frac{\partial z_j^l}{\partial w_{ij}^{(l-1)}}=z_i^{(l-1)} \\ \frac{\partial z_j^l}{\partial b_j^{(l-1)}}=1 \end{gathered}$$
以第1层参数更新为例：
$$\begin{gathered} \frac{\partial C}{\partial w_{11}^1}=\frac{\partial C}{\partial a}\ast \frac{\partial a}{\partial z_1^2}\ast \frac{\partial z_1^2}{\partial w_{11}^1}=\frac{\partial C}{\partial z_1^2}\ast z_1^1 \\ \frac{\partial C}{\partial b_1^1}=\frac{\partial C}{\partial a}\ast \frac{\partial a}{\partial z_1^2}\ast \frac{\partial z_1^2}{\partial b_1^1}=\frac{\partial C}{\partial z_1^2}\ast 1 \end{gathered}$$
写成矩阵形式，令${\delta }^l$为C对l层z偏导的向量，即${\delta }^l=\frac{\partial C}{\partial z^l}$，于是可以推导得到以下公式：
$$\begin{gathered} {\delta }^l=W^T{\delta }^{l+1} \\ \frac{\partial C}{\partial w^l}={\delta }^{l+1}\ast Z^{lT} \\ \frac{\partial C}{\partial w^l}={\delta }^{l+1} \end{gathered}$$
由以上两个公式可以得知，在反向传播过程中，可以将${\delta }^{l+1}$视为第$l$层的输入，${\delta }^l$为输出并作为$l-1$层的输入继续传播，${\delta }^{l+1}$结合前向传播中得到的$z^l$的转置可以得到损失函数对于该层权重和偏移参数的偏导数，以此来更新该层的参数。
代码如下：

import numpy as np
from abc import ABC, abstractmethod

sigmoid = np.vectorize(lambda z: 1 / (1 + np.exp(-z)))


class Layer(ABC):
    @abstractmethod
    def front_pro(self, inputs):
        pass

    @abstractmethod
    def back_pro(self, output_der):
        pass

    @abstractmethod
    def update(self, length, eta):
        pass


class DenseLayer(Layer):
    def __init__(self, *shape):
        self._weights = 0.1 * np.random.randn(*shape)
        self._bias = np.random.randn(shape[0], 1)
        self._temp_weight_delta = np.zeros_like(self._weights)
        self._temp_bias_delta = np.zeros_like(self._bias)
        self._input = np.array((shape[-1], 1))
        self._output = np.array((shape[0], 1))

    def front_pro(self, inputs):
        self._input = inputs
        # print(self._weights.shape)
        # print(np.array(inputs).shape)
        self._output = np.dot(self._weights, inputs) + self._bias
        # self._output = np.swapaxes(self._output, 1, 0)
        # print(self._output.shape)
        return self._output

    def back_pro(self, output_der):
        weight_delta = np.dot(output_der, self._input.transpose())
        self._temp_weight_delta += weight_delta
        bias_delta = output_der
        self._temp_bias_delta += bias_delta
        return np.dot(self._weights.transpose(), output_der)

    def update(self, length, eta):
        self._weights += self._temp_weight_delta / length * eta
        self._bias += self._temp_bias_delta / length * eta
        self._temp_weight_delta = np.zeros_like(self._weights)
        self._temp_bias_delta = np.zeros_like(self._bias)


class SigmoidLayer(Layer):
    def __init__(self, last_layer=False):
        self._output = np.array([])
        self._last_layer = last_layer

    def front_pro(self, inputs):
        self._output = sigmoid(inputs)
        return self._output

    def back_pro(self, output_der):
        if self._last_layer:
            return output_der
        return output_der * self._output * (1 - self._output)

    def update(self, length, eta):
        pass


class Network(object):
    # loss func: y*log(a)+(1-y)*log(1-a)

    def __init__(self):
        self._z = np.ndarray((1,))
        self._output = np.ndarray((1,))
        self._weights = np.ndarray((1,))
        self._bias = np.ndarray((1,))
        self._layers = []

    def add_layer(self, layer):
        self._layers.append(layer)

    def front_pro(self, inputs):
        output = []
        for input in inputs:
            for layer in self._layers:
                input = layer.front_pro(input)
            output.append(input)
        return output

    def back_pro(self, output_der):
        for layer in reversed(self._layers):
            output_der = layer.back_pro(output_der)

    def cross_entropy_der(self, output, label):
        return label / output - (1 - label) / (1 - output)

    def train(self, data_input, data_label, eta):
        for x, y in zip(data_input, data_label):
            x = np.expand_dims(x, 0)
            output = self.front_pro(x)
            output = output[0]
            # output_der = self.cross_entropy_der(output, y)
            output_der = y - output
            self.back_pro(output_der)
        for layer in self._layers:
            layer.update(len(data_input), eta)


def main():
    network = Network()
    network.add_layer(DenseLayer(2, 2))
    network.add_layer(DenseLayer(1, 2))
    network.add_layer(SigmoidLayer(last_layer=True))
    input_generator = lambda x: 5 * x + 20
    inputs = []
    for i in range(10):
        if i < 5:
            inputs.append(np.array([[i], [input_generator(i) + 20]]))
        else:
            inputs.append(np.array([[i], [input_generator(i) - 20]]))
    y = np.array([1] * 5 + [0] * 5).reshape((10, 1))

    print(np.array(network.front_pro(inputs)).reshape(10,))
    for j in range(60):
        for i in range(5):
            network.train(inputs[i:i + 2], y[i:i + 2], 0.05)

    print(np.array(network.front_pro(inputs)).reshape(10,))


if __name__ == '__main__':
    main()

以上仅使用了10组简单的数据来训练，如下：
[[ 0 40] [ 1 45] [ 2 50] [ 3 55] [ 4 60] [ 5 25] [ 6 30] [ 7 35] [ 8 40] [ 9 45]]
对应label如下：
[1 1 1 1 1 0 0 0 0 0]

训练前网络输出结果：
[0.70424612 0.7159282 0.7273275 0.73843649 0.74924892 0.66834236
0.68079983 0.6930043 0.70494438 0.71660998]

训练后：
[0.99848587 0.99706174 0.99430577 0.98899335 0.97883024 0.03070642
0.01604001 0.00831864 0.00429797 0.00221627]