深度学习：基于python
第5章 误差反向传播法
数值微 分虽然简单，也容易实现，但缺点是计算上比较费时间。本章我们将学习一 个能够高效计算权重参数的梯度的方法——误差反向传播法。
要正确理解误差反向传播法，我个人认为有两种方法：一种是基于数学式； 另一种是基于计算图（computational graph）
5.1 计算图
5.1.1 用计算图求解
问题2：太郎在超市买了2个苹果、3个橘子。其中，苹果每个100日元， 橘子每个150日元。消费税是10%，请计算支付金额。
综上，用计算图解题的情况下，需要按如下流程进行。
- 1.构建计算图。
- 2.在计算图上，从左向右进行计算。
这里的第2歩“从左向右进行计算”是一种正方向上的传播，简称为正向传播（forward propagation）。正向传播是从计算图出发点到结束点的传播
既然有正向传播这个名称，当然也可以考虑反向（从图上看的话，就是从右向左） 的传播。实际上，这种传播称为反向传播（backward propagation）。
5.1.2 局部计算
计算图的特征是可以通过传递“局部计算”获得最终结果。
局部计算是指，无论全局发生了什么， 都能只根据与自己相关的信息输出接下来的结果。
5.1.3 为何用计算图解题
综上，计算图的优点是，可以通过正向传播和反向传 播高效地计算各个变量的导数值。
5.2 链式法则
而反向传播将局部导数向正方向的反方向（从右到左）传递，一开始可能会让人感到困惑。 传递这个局部导数的原理，是基于链式法则（chain rule）的。
5.2.1 计算图的反向传播
5.2.2 什么是链式法则
链式法则是关于复合函数的导数的性质，定义如下。
如果某个函数由复合函数表示，则该复合函数的导数可以用构成复 合函数的各个函数的导数的乘积表示。
5.2.3 链式法则和计算图
*5.3 反向传播
本节将以“+” 和“×”等运算为例，介绍反向传播的结构
5.3.1 加法节点的反向传播
5.3.2 乘法节点的反向传播
乘法的反向传播会将上游的值乘以正向传播时的输入信号的**“翻转值”** 后传递给下游。翻转值表示一种翻转关系，
如图5-12所示，正向传播时信号 是x的话，反向传播时则是y；正向传播时信号是y的话，反向传播时则是x。
- 乘法的反向传播会乘以输入信号的翻转值，所以各自可按1.3 × 5 = 6.5、1.3 × 10 = 13计算。
- 乘法的反向传播需要正向传播时的输 入信号值。因此，实现乘法节点的反向传播时，要保存正向传播的输入信号。
- 另外，加法的反向传播只是将上游的值传给下游， 并不需要正向传播的输入信号。
5.3.3 苹果的例子
*5.4 简单层的实现
本节将用Python实现前面的购买苹果的例子。这里，我们把要实现 的计算图的乘法节点称为“乘法层”（MulLayer），加法节点称为“加法层” （AddLayer）。
我们将把构建神经网络的“层”实现为一个类。这里所 说的“层”是神经网络中功能的单位。比如，负责 sigmoid函数的 Sigmoid、负责矩阵乘积的Affine等，都以层为单位进行实现。因此， 这里也以层为单位来实现乘法节点和加法节点
5.4.1 乘法层的实现
层的实现中有两个共通的方法（接口）forward()和backward()。forward() 对应正向传播，backward()对应反向传播
class MulLayer:
def __init__(self):
self.x = None
self.y = None
def forward(self, x, y):
self.x = x
self.y = y
out = x * y
return out
def backward(self, dout):
dx = dout * self.y # 翻转x和y
dy = dout * self.x
return dx, dy
_ _ init _ _()中会初始化实例变量x和y，它们用于保存正向传播时的输入值。
forward()接收x和y两个参数，将它们相乘后输出。
backward()将从上游传来的导数（dout）乘以正向传播的翻转值，然后传给下游。
实现函数
apple = 100
apple_num = 2
tax = 1.1
# layer
mul_apple_layer = MulLayer() #记录苹果的价格*个数，还有此时dout
mul_tax_layer = MulLayer() #记录总价*消费税，还有此时dout
# forward
apple_price = mul_apple_layer.forward(apple, apple_num)
price = mul_tax_layer.forward(apple_price, tax)
print(price) # 220
# backward
dprice = 1
dapple_price, dtax = mul_tax_layer.backward(dprice)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)
print(dapple, dapple_num, dtax) # 2.2 110 200
**调用backward()的顺序与调用forward()的顺序相反。**此外，要注 意backward()的参数中需要输入“关于正向传播时的输出变量的导数”。比如， mul_apple_layer乘法层在正向传播时会输出apple_price，在反向传播时，则 会将apple_price的导数dapple_price设为参数。
5.4.2 加法层的实现
class AddLayer:
def __init__(self):
pass
def forward(self, x, y):
out = x + y
return out
def backward(self, dout):
dx = dout * 1
dy = dout * 1
return dx, dy
加法层不需要特意进行初始化，所以 _ _ init _ _()中什么也不运行
**加法层的forward()接收x和y两个参数，将它们相加后输出。**backward()将上游传来的导数（dout）原封不动地传递给下游。
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) # 715
print(dapple_num, dapple, dorange, dorange_num, dtax) # 110 2.2 3.3 165 650
综上，计算图中层的实现（这里是加法层和乘法层）非常简单，使用这 些层可以进行复杂的导数计算。下面，我们来实现神经网络中使用的层。
5.5 激活函数层的实现
现在，我们将计算图的思路应用到神经网络中。这里，我们把构成神经 网络的层实现为一个类。先来实现激活函数的ReLU层和Sigmoid层
5.5.1 ReLU层
class Relu:
def __init__(self):
self.mask = None
def forward(self, x):
self.mask = (x <= 0) #这里把小于等于0的数True
out = x.copy()
out[self.mask] = 0 #把小于等于0的全赋值0
return out
def backward(self, dout):
dout[self.mask] = 0
dx = dout
return dx
Relu类有实例变量mask。这个变量mask是由True/False构成的NumPy数组，它会把正向传播时的输入x的元素中小于等于0的地方保存为True，其他地方（大于0的元素）保存为False。
>>> x = np.array( [[1.0, -0.5], [-2.0, 3.0]] )
>>> print(x)
[[ 1. -0.5]
[-2. 3. ]]
>>> mask = (x <= 0)
>>> print(mask)
[[False True]
[ True False]]
out = x.copy()
print(out)
[[ 1. -0.5]
[-2. 3. ]]
out[mask] = 0
print(out)
[[1. 0.]
[0. 3.]]
如图5-18所示，如果正向传播时的输入值小于等于0，则反向传播的值为0。 因此，反向传播中会使用正向传播时保存的mask，将从上游传来的dout的 mask中的元素为True的地方设为0。
ReLU层的作用就像电路中的开关一样。正向传播时，有电流通过 的话，就将开关设为 ON；没有电流通过的话，就将开关设为 OFF。 反向传播时，开关为ON的话，电流会直接通过；开关为OFF的话， 则不会有电流通过
5.5.2 Sigmoid层
用Python实现Sigmoid层。
class Sigmoid:
def __init__(self):
self.out = None
def forward(self, x):
out = 1 / (1 + np.exp(-x))
self.out = out
return out
def backward(self, dout):
dx = dout * (1.0 - self.out) * self.out
return dx
正向传播时将输出保存在了实例变量out中。然后，反向 传播时，使用该变量out进行计算。
5.6 Affine/Softmax层的实现
5.6.1 Affine层
神经网络的正向传播中，为了计算加权信号的总和，使用了矩阵的乘 积运算（NumPy中是np.dot()，具体请参照3.3节）。
>>> X = np.random.rand(2) # 输入
>>> W = np.random.rand(2,3) # 权重
>>> B = np.random.rand(3) # 偏置
>>>
>>> X.shape # (2,)
>>> W.shape # (2, 3)
>>> B.shape # (3,)
>>>
>>> Y = np.dot(X, W) + B
求矩阵的乘积与偏置的和的运算用计算图表示出来。
5.6.2 批版本的Affine层
>>> X_dot_W = np.array([[0, 0, 0], [10, 10, 10]])
>>> B = np.array([1, 2, 3])
>>>
>>> X_dot_W
array([[ 0, 0, 0],
[ 10, 10, 10]])
>>> X_dot_W + B
array([[ 1, 2, 3],
[11, 12, 13]])
正向传播时，偏置会被加到每一个数据（第1个、第2个……）上。因此，
反向传播时，各个数据的反向传播的值需要汇总为偏置的元素。用代码表示 的话，如下所示。
>>> dY = np.array([[1, 2, 3,], [4, 5, 6]])
>>> dY
array([[1, 2, 3],
[4, 5, 6]])
>>>
>>> dB = np.sum(dY, axis=0)
>>> dB
array([5, 7, 9])
假定数据有2个（N = 2）。偏置的反向传播会对这2个数据 的导数按元素进行求和。因此，这里使用了np.sum()对第0轴（以数据为单 位的轴，axis=0）方向上的元素进行求和。
函数
class Affine:
def __init__(self, W, b):
self.W = W
self.b = b
self.x = None
self.dW = None
self.db = None
def forward(self, x):
self.x = x
out = np.dot(x, self.W) + self.b
return out
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
5.6.3 Softmax-with-Loss 层
前面我们提到过，softmax函数 会将输入值正规化之后再输出。
神经网络中进行的处理有推理（inference）和学习两个阶段。神经网络的推理通常不使用 Softmax层。
再举一个例子，比如思考教师标签是(0, 1, 0)，Softmax层的输出是(0.01, 0.99, 0)的情形（这个神经网络识别得相当准确）。此时Softmax层的反向传播 传递的是(0.01, −0.01, 0)这样一个小的误差。这个小的误差也会向前面的层 传播，因为误差很小，所以Softmax层前面的层学到的内容也很“小”。
函数
class SoftmaxWithLoss:
def __init__(self):
self.loss = None # 损失
self.y = None # softmax的输出
self.t = None # 监督数据（one-hot vector）
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]
dx = (self.y - self.t) / batch_size
return dx
请注意反向传播时，将要传播 的值除以批的大小（batch_size）后，传递给前面的层的是单个数据的误差
5.7 误差反向传播法的实现
本节我们将通过组装已经实现的层来构建神经网络。
5.7.1 神经网络学习的全貌图
神经网络学习的步骤如下所示
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nL5wixVZ-1638173310262)(G:\笔记\深度学习：基于python入门\5\40.png)]
5.7.2 对应误差反向传播法的神经网络的实现
类函数
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)
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'] = self.layers['Affine1'].dW
grads['b1'] = self.layers['Affine1'].db
grads['W2'] = self.layers['Affine2'].dW
grads['b2'] = self.layers['Affine2'].db
return grads
尤其是将神经网络的层保存为 OrderedDict这一点非常重要。
OrderedDict是有序字典，“有序”是指它可以 记住向字典里添加元素的顺序。
因此，神经网络的正向传播只需按照添加元素的顺序调用各层的forward()方法就可以完成处理，而反向传播只需要按 照相反的顺序调用各层即可。因为Affine层和ReLU层的内部会正确处理正 向传播和反向传播，所以这里要做的事情仅仅是以正确的顺序连接各层，再按顺序（或者逆序）调用各层。
像这样通过将神经网络的组成元素以层的方式实现，可以轻松地构建神 经网络。这个用层进行模块化的实现具有很大优点。因为想另外构建一个神 经网络（比如5层、10层、20层……的大的神经网络）时，只需像组装乐高 积木那样添加必要的层就可以了。之后，通过各个层内部实现的正向传播和 反向传播，就可以正确计算进行识别处理或学习所需的梯度。
5.7.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))
和以前一样，读入MNIST数据集。然后，使用训练数据的一部分，确认数值微分求出的梯度和误差反向传播法求出的梯度的误差。这里误差的计算方法是求各个权重参数中对应元素的差的绝对值，并计算其平均值。运行 上面的代码后，会输出如下结果
b1:9.70418809871e-13
W2:8.41139039497e-13
b2:1.1945999745e-10
W1:2.2232446644e-13
从这个结果可以看出，通过数值微分和误差反向传播法求出的梯度的差非常小。
这样一来， 我们就知道了通过误差反向传播法求出的梯度是正确的，误差反向传播法的 实现没有错误。
数值微分和误差反向传播法的计算结果之间的误差为 0是很少见的。 这是因为计算机的计算精度有限（比如，32位浮点数）。受到数值精 度的限制，刚才的误差一般不会为 0，但是如果实现正确的话，可 以期待这个误差是一个接近 0的很小的值。如果这个值很大，就说 明误差反向传播法的实现存在错误
5.7.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)
5.8 小结
本章我们介绍了将计算过程可视化的计算图，并使用计算图，介绍了神 经网络中的误差反向传播法，并以层为单位实现了神经网络中的处理。我们 学过的层有ReLU层、Softmax-with-Loss层、Affine层、Softmax层等，这 些层中实现了forward和backward方法，通过将数据正向和反向地传播，可 以高效地计算权重参数的梯度。通过使用层进行模块化，神经网络中可以自 由地组装层，轻松构建出自己喜欢的网络
- 通过使用计算图，可以直观地把握计算过程。
- 计算图的节点是由局部计算构成的。局部计算构成全局计算。
- 计算图的正向传播进行一般的计算。通过计算图的反向传播，可以 计算各个节点的导数。
- 通过将神经网络的组成元素实现为层，可以高效地计算梯度（反向传播法）。
- 通过比较数值微分和误差反向传播法的结果，可以确认误差反向传 播法的实现是否正确（梯度确认）。
1261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
