自己动手实现一个深度学习算法——五、误差反向传播法

五、误差反向传播法

数值微分虽然简单，也容易实现，但缺点是计算上比较费时间。误差反向传播法是一个能够高效计算权重参数的梯度的方法。

本章所学的内容
• 通过使用计算图，可以直观地把握计算过程。
• 计算图的节点是由局部计算构成的。局部计算构成全局计算。
• 计算图的正向传播进行一般的计算。通过计算图的反向传播，可以计算各个节点的导数。
• 通过将神经网络的组成元素实现为层，可以高效地计算梯度（反向传播法）。
• 通过比较数值微分和误差反向传播法的结果，可以确认误差反向传播法的实现是否正确（梯度确认）。

1.计算图

反向传播，将局部导数向正方向的反方向（从右到左）传递。传递这个局部导数的原理，是基于链式法则（chain rule）的。

计算图的反向传播：沿着与正方向相反的方向，乘上局部导数

1）概念

链式法则是关于复合函数的导数的性质。

如果某个函数由复合函数表示，则该复合函数的导数可以用构成复合函数的各个函数的导数的乘积表示。

2）计算图

问题1： 太郎在超市买了2个100日元一个的苹果，消费税是10%，请计算支付金额。

“苹果的个数”和“消费税”作为变量标在○外面

问题2： 太郎在超市买了2个苹果、3个橘子。其中，苹果每个100日元，橘子每个150日元。消费税是10%，请计算支付金额。

求解过程

这个问题中新增了加法节点“+”，用来合计苹果和橘子的金额。构建了计算图后，从左向右进行计算。就像电路中的电流流动一样，计算结果从左向右传递。到达最右边的计算结果后，计算过程就结束了。

综上，用计算图解题的情况下，需要按如下流程进行。

1. 构建计算图。
2. 在计算图上，从左向右进行计算。

这里的第2歩“从左向右进行计算”是一种正方向上的传播，简称为正向传播（forward propagation）。正向传播是从计算图出发点到结束点的传播。既然有正向传播这个名称，当然也可以考虑反向（从图上看的话，就是从右向左）的传播。实际上，这种传播称为反向传播（backward propagation）。反向传播将在接下来的导数计算中发挥重要作用。

3）局部计算

计算图的特征是可以通过传递“局部计算”获得最终结果。“局部”这个词的意思是“与自己相关的某个小范围”。局部计算是指，无论全局发生了什么，都能只根据与自己相关的信息输出接下来的结果。

用一个具体的例子来说明局部计算。比如，在超市买了2个苹果和其他很多东西。可以画出如下所示的计算图

假设（经过复杂的计算）购买的其他很多东西总共花费4000 日元。这里的重点是，各个节点处的计算都是局部计算。这意味着，例如苹果和其他很多东西的求和运算（4000 + 200→4200）并不关心 4000 这个数字是如何计算而来的，只要把两个数字相加就可以了。换言之，各个节点处只需进行与自己有关的计算（在这个例子中是对输入的两个数字进行加法运算），不用考虑全局。

综上，计算图可以集中精力于局部计算。无论全局的计算有多么复杂，各个步骤所要做的就是对象节点的局部计算。虽然局部计算非常简单，但是通过传递它的计算结果，可以获得全局的复杂计算的结果。

比如，组装汽车是一个复杂的工作，通常需要进行“流水线”作业。每个工人（机器）所承担的都是被简化了的工作，这个工作的成果会传递给下一个工人，直至汽车组装完成。计算图将复杂的计算分割成简单的局部计算，和流水线作业一样，将局部计算的结果传递给下一个节点。在将复杂的计算分解成简单的计算这一点上与汽车的组装有相似之处。

4）计算图解题优点

一个优点就在于前面所说的局部计算。无论全局是多么复杂的计算，都可以通过局部计算使各个节点致力于简单的计算，从而简化问题。另一个优点是，利用计算图可以将中间的计算结果全部保存起来（比如，计算进行到2个苹果时的金额是200日元、加上消费税之前的金额650日元等）

不止如此，使用计算图最大的原因是，可以通过反向传播高效计算导数。

假设我们想知道苹果价格的上涨会在多大程度上影响最终的支付金额，即求“支付金额关于苹果的价格的导数”。设苹果的价格为x，支付金额为L，则相当于求
。这个导数的值表示当苹果的价格稍微上涨时，支付金额会增加多少。

可以通过计算图的反向传播求导数。

如上图所示，反向传播使用与正方向相反的箭头（粗线）表示。反向传播传递“局部导数”，将导数的值写在箭头的下方。在这个例子中，反向传播从右向左传递导数的值（1→1.1→2.2）。从这个结果中可知，“支付金额关于苹果的价格的导数”的值是2.2。这意味着，如果苹果的价格上涨1日元，最终的支付金额会增加2.2日元（严格地讲，如果苹果的价格增加某个微小值，则最终的支付金额将增加那个微小值的2.2倍）。

这里只求了关于苹果的价格的导数，不过“支付金额关于消费税的导数”“支付金额关于苹果的个数的导数”等也都可以用同样的方式算出来。并且，计算中途求得的导数的结果（中间传递的导数）可以被共享，从而可以高效地计算多个导数。综上，计算图的优点是，可以通过正向传播和反向传播高效地计算各个变量的导数值。

反向传播的计算顺序是，先将节点的输入信号乘以节点的局部导数（偏导数），然后再传递给下一个节点。

2.链式法则

反向传播，将局部导数向正方向的反方向（从右到左）传递，传递这个局部导数的原理，是基于链式法则（chain rule）的。

1）计算图的反向传播

假设存在y = f (x) 的计算，这个计算的反向传播如下图 所示。

计算图的反向传播：沿着与正方向相反的方向，乘上局部导数。

2)什么是链式法则

介绍链式法则时，我们需要先从复合函数说起。复合函数是由多个函数构成的函数。比如，z = $(x+y{)}^2$是由两个式子构成的:z=$t^2$和t=x+y。链式法则是关于复合函数的导数的性质，定义如下：如果某个函数由复合函数表示，则该复合函数的导数可以用构成复合函数的各个函数的导数的乘积表示。用数学式表示的话，可以写成下式

完整解析解如下

3）链式法则和计算图

尝试将式上式的链式法则的计算用计算图表示出来。如果用“**2”节点表示平方运算的话，则计算图如下所示。

3.反向传播

1）加法节点的反向传播

也就是说，因为加法节点的反向传播只乘以1，所以输入的值会原封不动地流向下一个节点。

2）乘法的反向传播

乘法的反向传播会将上游的值乘以正向传播时的输入信号的“翻转值”后传递给下游。

3）苹果的例子

苹果的价格、苹果的个数、消费税这3个变量各自如何影响最终支付的金额。这个问题相当于求“支付金额关于苹果的价格的导数”“支付金额关于苹果的个数的导数”“支付金额关于消费税的导数”。用计算图的反向传播来解的话，求解过程如图

如前所述，乘法节点的反向传播会将输入信号翻转后传给下游。从上图的结果可知，苹果的价格的导数是2.2，苹果的个数的导数是110，消费税的导数是200。这可以解释为，如果消费税和苹果的价格增加相同的值，则消费税将对最终价格产生200倍大小的影响，苹果的价格将产生2.2倍大小的影响。不过，因为这个例子中消费税和苹果的价格的量纲不同，所以才形成了这样的结果（消费税的1是100%，苹果的价格的1是1日元）。

4）简单实现

layer_naive.py文件实现乘法层和加法层

# coding: utf-8

#加法层实现
class MulLayer:
    #初始化实例变量 x 和 y，用于保存正向传播时的输入值。
    def __init__(self):
        self.x = None
        self.y = None

    #前向传播函数
    #forward() 接收 x 和 y 两个参数，将它们相乘后输出。
    def forward(self, x, y):
        self.x = x
        self.y = y                
        out = x * y

        return out

    #将从上游传来的导数（dout）乘以正向传播的翻转值，然后传给下游。
    def backward(self, dout):
        dx = dout * self.y
        dy = dout * self.x

        return dx, dy

#乘法层
class AddLayer:
    def __init__(self):
        #无操作，这个类不需要初始化任何参数。
        pass
    #前向传播函数
    #计算输入值x和y的和
    def forward(self, x, y):
        out = x + y

        return out
    #反向传播函数 
    #backward()将上游传来的导数（dout）原封不动地传递给下游。
    def backward(self, dout):
        dx = dout * 1
        dy = dout * 1

        return dx, dy

使用Mul Layer实现购买苹果，buy_apple.py

# coding: utf-8
from layer_naive import *


apple = 100
apple_num = 2
tax = 1.1

mul_apple_layer = MulLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple, apple_num)
price = mul_tax_layer.forward(apple_price, tax)

# backward
#对自己求导
dprice = 1
#计算苹果价格和税率的导数
dapple_price, dtax = mul_tax_layer.backward(dprice)
#计算苹果单价和苹果数量的导数
dapple, dapple_num = mul_apple_layer.backward(dapple_price)

print("price:", int(price))
print("dApple:", dapple)
print("dApple_num:", int(dapple_num))
print("dTax:", dtax)

这里，调用backward()的顺序与调用forward()的顺序相反。

下面用加法层和乘法层，实现购买2个苹果和3个橘子的代码。

# coding: utf-8
from layer_naive import *

apple = 100
apple_num = 2
orange = 150
orange_num = 3
tax = 1.1

# layer
mul_apple_layer = MulLayer()
mul_orange_layer = MulLayer()
add_apple_orange_layer = AddLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple, apple_num)  # (1)
orange_price = mul_orange_layer.forward(orange, orange_num)  # (2)
all_price = add_apple_orange_layer.forward(apple_price, orange_price)  # (3)
price = mul_tax_layer.forward(all_price, tax)  # (4)

# backward
dprice = 1
#求苹果橘子总价和税率的导师
dall_price, dtax = mul_tax_layer.backward(dprice)  # (4)

dapple_price, dorange_price = add_apple_orange_layer.backward(dall_price)  # (3)
dorange, dorange_num = mul_orange_layer.backward(dorange_price)  # (2)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)  # (1)

print("price:", int(price))
print("dApple:", dapple)
print("dApple_num:", int(dapple_num))
print("dOrange:", dorange)
print("dOrange_num:", int(dorange_num))
print("dTax:", dtax)

首先，生成必要的层，以合适的顺序调用正向传播的forward()方法。然后，用与正向传播相反的顺序调用反向传播的backward()方法，就可以求出想要的导数。

4.激活函数层的实现

1)ReLU层

激活函数ReLU（Rectified Linear Unit）由下式表示。

y关于x的导数

如果正向传播时的输入x大于0，则反向传播会将上游的值原封不动地传给下游。反过来，如果正向传播时的x小于等于0，则反向传播中传给下游的信号将停在此处。用计算图表示如下

实现代码如下：

class Relu:
    def __init__(self):
        self.mask = None
    # 定义前向传播函数，输入参数为x，参数x是NumPy数组,返回计算结果  
# mask 是由 True/False 构成的 NumPy 数组，它会把正向传播时的输入x的元素中小于等于0的地方保存为True，其他地方（大于0的元素）保存为False。
	
    
    def forward(self, x):
        #创建一个mask，其值为x是否小于等于0的布尔值  
        self.mask = (x <= 0)
        # 创建一个x的副本，存储后续计算结果  
        out = x.copy()
        # 将mask中为True的对应位置的值设置为0，实现ReLU的功能  
        out[self.mask] = 0

        return out
	# 定义反向传播函数，输入参数为dout（梯度），返回计算结果  
    def backward(self, dout):
        # 在dout中，将mask中为True的对应位置的值设置为0，实现ReLU的反向传播特性 
        dout[self.mask] = 0
        # 这里直接返回dout作为梯度，因为ReLU的梯度在正向输入部分是1，反向输入部分是0  
        dx = dout
		# 返回计算结果，即梯度dx
        return dx

2)Sigmoid层实现

sigmoid函数由下式表示

计算图表示式如下，（仅正向传播）

除了“×”和“+”节点外，还出现了新的“exp”和“/”节点。“exp”节点会进行y = exp(x)的计算，“/”节点会进行y=1/x 的计算。

反向传播计算图如下

简洁版如下

实现代码如下：

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

    def forward(self, x):
        out = sigmoid(x)
        self.out = out
        return out

    def backward(self, dout):
        dx = dout * (1.0 - self.out) * self.out

        return dx

5.Affine/Softmax层的实现

1）Affine层

神经网络的正向传播中进行的矩阵的乘积运算在几何学领域被称为“仿射变换”。因此，这里将进行仿射变换的处理实现为“Affine层”.

将乘积运算用“dot”节点表示的话，则np.dot(X, W) + B的运算可用下图所示的计算图表示出来。

以矩阵为对象的反向传播，按矩阵的各个元素进行计算时，步骤和以标量为对象的计算图相同。

计算图的反向传播如下：

2）批版本的Affine层

批版本的Affine层的计算图如下

正向传播时，偏置被加到X·W的各个数据上。

import numpy as np
X_dot_W = np.array([[0, 0, 0], [10, 10, 10]])
B = np.array([1, 2, 3])
print(X_dot_W + B)

输出：

[[ 1 2 3]
[11 12 13]]

反向传播时，各个数据的反向传播的值需要汇总为偏置的元素。

import numpy as np
dY = np.array([[1, 2, 3,], [4, 5, 6]])
dB = np.sum(dY, axis=0)
print(dB)

输出：[5 7 9]

3）Softmax-with-Loss 层

输入图像通过Affi ne层和ReLU层进行转换，10个输入通过Softmax层进行正规化。如下

在这个例子中，“0”的得分是 5.3，这个值经过 Softmax 层转换为 0.008（0.8%）；“2”的得分是10.1，被转换为0.991（99.1%）

因为手写数字识别要进行10类分类，所以向Softmax层的输入也有10个。

神经网络中进行的处理有推理（inference）和学习两个阶段。神经网络的推理通常不使用Softmax层。比如，用图5-28的网络进行推理时，会将最后一个Affine层的输出作为识别结果。神经网络中未被正规化的输出结果（图5-28中Softmax层前面的Affine层的输出）有时被称为“得分”。也就是说，当神经网络的推理只需要给出一个答案的情况下，因为此时只对得分最大值感兴趣，所以不需要Softmax层。不过，神经网络的学习阶段则需要Softmax层。

Softmax-with-Loss层的计算图如下

Softmax层的反向传播得到了（y1 −t1, y2 −t2, y3 −t3）这样“漂亮”的结果。由于（y1, y2, y3）是Softmax层的输出，（t1, t2, t3）是监督数据，所以（y1 −t1, y2 −t2, y3 −t3）是Softmax层的输出和教师标签的差分。神经网络的反向传播会把这个差分表示的误差传递给前面的层，这是神经网络学习中的重要性质。

**神经网络学习的目的就是通过调整权重参数，使神经网络的输出（Softmax的输出）接近教师标签。因此，必须将神经网络的输出与教师标签的误差高效地传递给前面的层。**刚刚的（y1 −t1, y2 −t2, y3 −t3）正是Softmax层的输出与教师标签的差，直截了当地表示了当前神经网络的输出与教师标签的误差。

这里考虑一个具体的例子，比如思考教师标签是（0, 1, 0），Softmax层的输出是(0.3, 0.2, 0.5)的情形。因为正确解标签处的概率是0.2（20%），这个时候的神经网络未能进行正确的识别。此时，Softmax层的反向传播传递的是(0.3,−0.8, 0.5) 这样一个大的误差。因为这个大的误差会向前面的层传播，所以Softmax层前面的层会从这个大的误差中学习到“大”的内容。

使用交叉熵误差作为 softmax 函数的损失函数后，反向传播得到（y1 −t1, y2 −t2, y3 −t3）这样 “漂亮”的结果。实际上，这样“漂亮”的结果并不是偶然的，而是为了得到这样的结果，特意设计了交叉熵误差函数。回归问题中输出层使用“恒等函数”，损失函数使用“平方和误差”，也是出于同样的理由。也就是说，使用“平方和误差”作为“恒等函数”的损失函数，反向传播才能得到（y1 −t1, y2 −t2, y3 −t3）这样“漂亮”的结果。

实现代码如下：

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

反向传播时，将要传播的值除以批的大小（batch_size）后，传递给前面的层的是单个数据的误差。

6.误差反向传播法的实现

1）神经网络学习的步骤

前提
神经网络中有合适的权重和偏置，调整权重和偏置以便拟合训练数据的过程称为学习。神经网络的学习分为下面4个步骤。
步骤1（mini-batch）
从训练数据中随机选择一部分数据。
步骤2（计算梯度）
计算损失函数关于各个权重参数的梯度。
步骤3（更新参数）
将权重参数沿梯度方向进行微小的更新。
步骤4（重复）
重复步骤1、步骤2、步骤3。

之前介绍的误差反向传播法会在步骤2中出现。上一章中，我们利用数值微分求得了这个梯度。数值微分虽然实现简单，但是计算要耗费较多的时间。和需要花费较多时间的数值微分不同，误差反向传播法可以快速高效地计算梯度。

2）对应误差反向传播法的神经网络的实现

把2层神经网络实现为Two Layer Net。和上一章学习算法的实现有很多共通的部分，不同点主要在于这里使用了层。通过使用层，获得识别结果的处理（predict()）和计算梯度的处理（gradient()）只需通过层之间的传递就能完成。

   # 生成层
        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
    
    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'] = self.layers['Affine1'].dW
            grads['b1'] = self.layers['Affine1'].db
            grads['W2'] = self.layers['Affine2'].dW
            grads['b2'] = self.layers['Affine2'].db
            return grads

Ordered Dict 是有序字典，“有序”是指它可以记住向字典里添加元素的顺序。神经网络的正向传播只需按照添加元素的顺序调用各层的forward()方法就可以完成处理，而反向传播只需要按照相反的顺序调用各层即可。因为Affine层和ReLU层的内部会正确处理正向传播和反向传播，所以这里要做的事情仅仅是以正确的顺序连接各层，再按顺序（或者逆序）调用各层。

3）误差反向传播法的梯度确认

经常会比较数值微分的结果和误差反向传播法的结果，以确认误差反向传播法的实现是否正确。确认数值微分求出的梯度结果和误差反向传播法求出的结果是否一致（严格地讲，是非常相近）的操作称为梯度确认（gradient check）。梯度确认的代码如下

# 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))

4）使用误差反向传播法的学习

# 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)

iters_num = 10000
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 梯度
    #grad = network.numerical_gradient(x_batch, t_batch)
    grad = network.gradient(x_batch, t_batch)
    
    # 更新
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print(train_acc, test_acc)