误差反向传播法

一 个能够高效计算权重参数的梯度的方法

计算图

正向传播

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

反向传播（导数）

如果苹果的价格增加某个微小值， 则最终的支付金额将增加那个微小值的 2.2 倍

链式法则（可以了解下复合函数的链式求导法则）

反向传播的计算顺序是，将信号 E 乘以节点的局部导数 ( )，然后将结果传递给下一个节点

复合函数链式求导法则，这里略。

链式法则和计算图

反向传播

加法节点的反向传播将上游的值原封不动地输出到下游

乘法的反向传播会乘以输入信号的翻转值

简单例子：

简单层的实现

乘法层的实现

class MulLayer:def __init__(self):self.x = None self.y = Nonedef forward(self, x, y): self.x = xself.y = y out = x * yreturn outdef backward(self, dout):dx = dout * self.y # 翻转x和y dy = dout * self.xreturn dx, dy

例子：

# 正向传播
apple = 100 
apple_num = 2 
tax = 1.1
# layer
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)
print(price) # 220# 反向传播
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

加法层的实现

略

激活函数层的实现

ReLU 层

ReLU表达式、导数式、计算图：

python实现：

class Relu:def __init__(self):# 由 True/False 构成的 NumPy 数组self.mask = Nonedef forward(self, x): # 根据是否x<=0将x数组转化成True/False数组self.mask = (x <= 0) out = x.copy() # 是True的也就是x<=0的就输出0，其他的不变out[self.mask] = 0return outdef backward(self, dout): # 若为true则表示x<=0此时输出0 其他的不变dout[self.mask] = 0 dx = doutreturn dx

Sigmoid 层

表达式、计算图

其中一些注意的地方：

• “/”节点表示 y = 1/x，它的导数表达式为：
• “exp”节点表示y = exp(x)，导数仍为exp(x)
• 反向的输出结果可以进行简化推导：

可以得到完整的计算图为：

简化为：

Python 实现 Sigmoid 层

class Sigmoid:def __init__(self):self.out = Nonedef forward(self, x):out = 1 / (1 + np.exp(-x)) self.out = outreturn outdef backward(self, dout):dx = dout * (1.0 - self.out) * self.outreturn dx

Affine/Softmax 层的实现

Affine 层

神经网络的正向传播中进行的矩阵的乘积运算在几何学领域被称为“仿射变换”(几何中，仿射变换包括一次线性变换和一次平移，分别对应神经网络的加权和运算与加偏置运算)。因此，这里将进行仿射变换的处理实现为“Affine 层”。
复习一下内积

Affine层计算图（3，） = （1，3）：

批版本的 Affine 层

N批：

正向传播时，偏置会被加到每一个数据(第 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])

python实现：

class Affine:def __init__(self, W, b):self.W = W self.b = b self.x = None self.dW = None self.db = Nonedef forward(self, x): self.x = xout = np.dot(x, self.W) + self.breturn outdef backward(self, dout):# .T转置dx = np.dot(dout, self.W.T) self.dW = np.dot(self.x.T, dout) self.db = np.sum(dout, axis=0)return dx

Softmax-with-Loss 层

Softmax 层。考虑到这里也包含作为损失函数的交叉熵误差(cross entropy error)，所以称为“Softmax-with-Loss层”

计算图：

简化版：

由于(y1, y2, y3)是 Softmax 层的输出，(t1, t2, t3)是监督数据，所以(y1 − t1, y2 − t2, y3 − t3)是 Softmax 层的输 出和教师标签的差分

python实现：

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 = tself.y = softmax(x)self.loss = cross_entropy_error(self.y, self.t)return self.lossdef backward(self, dout=1):batch_size = self.t.shape[0]# 批的大小(batch_size)dx = (self.y - self.t) / batch_sizereturn dx

误差反向传播法的实现

在步骤2（计算损失函数关于各个权重参数的梯度）计算梯度中，数值微分虽然实现简单，但是计算要耗费较多的时间。和需要花费较多时间的数值微分不同，误差反向传播法可以快速高效地计算梯度。

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

主要在于这里使用了层。通过使用层，获得识别结果的处理(predict())和计算梯度的处理(gradient())只需通过层之间的传递就能完成

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)# 生成层# OrderedDict 是有序字典，“有序”是指它可以记住向字典里添加元素的顺序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)# backwarddout = 1dout = 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'].dbreturn grads

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

确认数值 微分求出的梯度结果和误差反向传播法求出的结果是否一致(严格地讲，是 非常相近)的操作称为梯度确认(gradient check)

python代码实现：

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

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

# 通过误差反向传播法求梯度（在实现基础上的替换）
grad = network.gradient(x_batch, t_batch)

小结

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