导语

书上在前一章介绍了随机梯度下降法进行参数与权重的学习，但是实际上，SGD的训练过程很慢，并且，神经网络层与层之间是存在数学关系的，SGD并没有利用好他们间的这种关系，相比之下，利用数学式关系的误差反向传播，无论是在效率还是速度上都相较于随机梯度下降更胜一筹，也更为常用。

计算图

书上采用了计算图来描述传播过程，这里的图和数据结构中的图定义一样，简单实例如下：

如图，一般来说，计算图时一个有向无环图，使用计算图时需要先构建，然后再从左往右计算，像从左到右的计算方向，称之为正向传播（从出发点到结束点，有点类似网络流）。

计算图可以通过传递局部计算的结果来一层层的获得最终结果，如图中的x×y，这是一个局部结果，并不会干扰别的传递，计算图就是通过一步一步，一个个局部运算，最后得到结果的。

反向传播

如图，反向传播的计算顺序与正向传播相反，将信号E乘以局部导数，然后将结果传递下一个节点，局部导数为y关于x的导数，因为存在多参数的情况，所以这里是偏导，这种偏导是基于链式法则来实现的。

链式法则

链式法则是关于复合函数导数的性质，定义为：如果某个函数由复合函数表示，则该复合函数的导数可以由构成函数的各个函数的导数乘积表示。

具体的例子和证明属于高等数学内容，略，这里只说明链式法则和计算图的内容，一个简单的示例图如下。

根据链式法则∂z/∂t · ∂t/∂x=∂z/∂x，而原式$z=(x-y{)}^2$，则∂z/∂x=$2(x-y)$

反向传播结构

一般来说，计算图涉及到的运算都可以用加法和乘法表示，减法可以变成加负数，除法可以变成乘倒数，因此书上主要介绍了反向传播的加法节点和乘法节点的结构。

加法节点

以$z=x+y$为例，计算图表示如下：

z对x,y的偏导都为1，反向传播图如下：

书上把上游传来的导数值设为∂L/∂z（最终输出值），由于链式法则，反向传播向下传递时要乘以z对x,y的偏导。

乘法节点

以$z=xy$为例，计算图表示如下：

z对x,y的偏导分别为y、x，反向传播图如下：

可以看到，加法的反向传播只是将上游值传给下游，是不需要输入信号的，但是乘法的反向传播是需要正向传播的输入信号的。

实现简单层

承接上文，实现计算图中的乘法节点的，就是乘法层，实现加法节点就是加法层。

加法

给出书上的代码，方便理解加上了注释，按照个人习惯修改了一下：

class MulLayer:
    def __init__(self):#初始化
        self.x = None
        self.y = None

    def forward(self, x, y):#赋值和返回正向传播结果
        self.x=x
        self.y=y                
        return x*y

    def backward(self, dout):#返回反向传播结果，注意需要输入导数
        return dout*self.y,dout*self.x
        

乘法

同上：

class AddLayer:
    def __init__(self):#不需初始化
        pass

    def forward(self, x, y):#正向传播
        return x+y

    def backward(self, dout):#反向传播
        return dout*1,dout*1

激活函数层实现

在书的上一章实现了神经网络的学习，但是只有学习过程是不够的，还需要激活函数，对得到的结果进行取舍，书上在本章进行了激活函数层的实现。

ReLU

ReLU函数的性质不再赘述，可以参考神经网络简介，这里只给出计算图：

这里给出书上的实现，加上了一些注释：

class Relu:
    def __init__(self):
        self.mask = None

    def forward(self, x):
        self.mask = (x <= 0)#返回所有非正下标
        out = x.copy()#深复制
        out[self.mask] = 0#对应下标全部置0
        return out

    def backward(self, dout):
        dout[self.mask] = 0#对应下标全部置0
        return dout

Sigmoid

这里跳过了sigmod内部各个节点的传递过程，将其视为一个整体，直接给出计算图：

书上的实现：

class Sigmoid:
    def __init__(self):
        self.out = None

    def forward(self, x):
        out = sigmoid(x)#输出
        self.out = out#赋值
        return out

    def backward(self, dout):
        return dout*(1.0-self.out)*self.out#反向传播的导数式子

Affine/Softmax层实现

上文所给的函数，操作对象都是单个的数值，然而在神经网络中，我们操作的总是矩阵，因此需要对应的运算层来实现运算。

Affine

Affine用来实现神经网络的正向传播中的矩阵乘积运算，式子表达为$Y=XW+B$，这里的计算图采用书上的例子，即取各数据维度：$X$为$(2,)$、$W$为$(2,3)$、$B$为$(3,)$，基本计算图如下：

基础版

矩阵计算图的反向传播和前文的道理一样，书上给出了反向传播的推导结果：
$$\begin{array}{r}(1)\frac{\partial L}{\partial X}=\frac{\partial L}{\partial Y}{W}^T\\ \\ (2)\frac{\partial L}{\partial W}=X^T\frac{\partial L}{\partial Y}\end{array}$$

反向传播的计算图如下，数字为对应的式子,$X$应该和$\frac{\partial L}{\partial X}$形状相同，$W$应该和$\frac{\partial L}{\partial W}$形状相同。

批版本

现在考虑N个数据一起进行正向传播的情况，即批版本Affine层，相较于只处理单个数据，批版本多加了一维，式子如下：

$$\begin{array}{r}(3)\frac{\partial L}{\partial B}=\frac{\partial L}{\partial Y}\end{array}$$

计算图如下，可以看到都多加了一维，输入从一个数组变成了矩阵。

需要注意的是，就偏置值来说，正向传播和反向传播的处理方式是不一样的，正向传播只需要对每个数据加上相同的偏置值，但是反向传播，由于上有传回的数据不同，所以得到的偏导也可能不同，所以反向传播时得到的应该是一个数组。

书上给出的实现如下：

class Affine:
    def __init__(self, W, b):
        self.W =W
        self.b = b
        self.x = None
        self.original_x_shape = None
        # 权重和偏置参数的导数
        self.dW = None
        self.db = None

    def forward(self, x):
        # 对应张量
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)#重新拉伸
        self.x = x
        return np.dot(self.x, self.W) + self.b

    def backward(self, dout):
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0) 
        return dx.reshape(*self.original_x_shape)# 还原输入数据的形状（对应张量）

Softmax-with-Loss

书上给出的softmax层的实现包括了损失函数，因此叫Softmax-with-Loss，由于太过复杂没办法重绘，这里给出书上设计图：

简化版的如下，这里假设要进行三类分类。

书上给出的代码实现如下：

class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None
        self.y = None # softmax的输出
        self.t = None # 监督数据

    def forward(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)
        return self.loss

    def backward(self, dout=1):#反向传播时要除以批大小，传递前面的层是单个数据的误差
        batch_size = self.t.shape[0]
        if self.t.size == self.y.size: # 监督数据是one-hot-vector的情况
            dx = (self.y - self.t) / batch_size
        else:
            dx = self.y.copy()
            dx[np.arange(batch_size), self.t] -= 1
            dx = dx / batch_size
        return dx

误差反向传播实现

上一章的神经网络实现使用数值微分求得，在使用时效率很低，如果使用误差反向传播效率会更高，这里给出书上的两层网络实现，加上了一些注释：

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from common.layers import *
from common.gradient import numerical_gradient
from collections import OrderedDict


class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
        #输入规模，隐藏层规模，输出规模，分布参数
        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)#高斯本部
        self.params['b1'] = np.zeros(hidden_size)#全置0
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) 
        self.params['b2'] = np.zeros(output_size)

        # 生成层
        self.layers = OrderedDict()#有序字典，记住向字典添加的顺序，可以认为拿字符串作为每一层的下标了
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])#传入参数，生成层
        self.layers['Relu1'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

        self.lastLayer = SoftmaxWithLoss()#最后一层
        
    def predict(self, x):#递推，每一层的结果作为下一层输入
        for layer in self.layers.values():
            x = layer.forward(x)
        return x
        
    # x:输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
    
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1 : t = np.argmax(t, axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
        
    # x:输入数据, t:监督数据
    def numerical_gradient(self, x, t):#反向传播算梯度
        loss_W = lambda W: self.loss(x, t)
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        return grads
        
    def gradient(self, x, t):
        # forward
        self.loss(x, t)
        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:#一层层往回推
            dout = layer.backward(dout)
        # 设定
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
        return grads

训练的源码略，只需要进行下列修改即可。

学习的结果如下，输出的是训练集和测试集上的准确度：

梯度确认

与反向传播相比，数值微分的效率显得捉襟见肘，这是否意味着数值微分没有用武之地了呢？并不是，由于误差反向传播实现很复杂，所以很容易出错，因此，在用误差传播得到结果后，可以用数值微分的结果进行比对，确认误差传播的实现是否正确，这样的过程就是梯度确认，书上给的代码如下：

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)#拿数据

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)#构造神经网络

x_batch = x_train[:3]
t_batch = t_train[:3]

grad_numerical = network.numerical_gradient(x_batch, t_batch)#数值微分
grad_backprop = network.gradient(x_batch, t_batch)#反向传播

for key in grad_numerical.keys():
    diff = np.average( np.abs(grad_backprop[key] - grad_numerical[key]) )
    #秋各个权重的绝对误差平均值
    print(key + ":" + str(diff))

运行结果：

总结

相较于数值微分，误差反向传播是一个更好的实现方式，但是理解上和实现上也增加了困难，并且由于其自身的复杂性，往往还需要数值微分进行结果的比对。

参考文献

1. 《深度学习入门——基于Python的理论与实现》