深度学习：基于python 第五章：误差反向传播法

您所在的位置：网站首页 › 反向传递神经网络的例子 › 深度学习：基于python 第五章：误差反向传播法

深度学习：基于python 第五章：误差反向传播法

2024-05-31 23:45| 来源: 网络整理| 查看: 265

深度学习：基于python 第5章误差反向传播法5.1 计算图5.1.1　用计算图求解5.1.2　局部计算5.1.3　为何用计算图解题 5.2 链式法则5.2.1 计算图的反向传播5.2.2　什么是链式法则5.2.3　链式法则和计算图 *5.3 反向传播5.3.1　加法节点的反向传播5.3.2　乘法节点的反向传播5.3.3　苹果的例子 *5.4 简单层的实现5.4.1　乘法层的实现5.4.2　加法层的实现 5.5 激活函数层的实现5.5.1　ReLU层5.5.2　Sigmoid层**用Python实现Sigmoid层。** 5.6 Affine/Softmax层的实现5.6.1　Affine层5.6.2　批版本的Affine层函数 5.6.3　Softmax-with-Loss 层函数 5.7 误差反向传播法的实现5.7.1　神经网络学习的全貌图5.7.2　对应误差反向传播法的神经网络的实现类函数 5.7.3　误差反向传播法的梯度确认5.7.4　使用误差反向传播法的学习5.8 小结

第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 >> x = np.array( [[1.0, -0.5], [-2.0, 3.0]] ) >>> print(x) [[ 1. -0.5] [-2. 3. ]] >>> mask = (x >> 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方法，通过将数据正向和反向地传播，可以高效地计算权重参数的梯度。通过使用层进行模块化，神经网络中可以自由地组装层，轻松构建出自己喜欢的网络

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

【本文地址】

深度学习：基于python 第五章：误差反向传播法

深度学习：基于python 第五章：误差反向传播法

今日新闻

推荐新闻