误差反向传播法
一 个能够高效计算权重参数的梯度的方法
计算图
正向传播
太郎在超市买了 2 个 100 日元一个的苹果，消费税是 10%，请计 算支付金额。
反向传播（导数）
如果苹果的价格增加某个微小值， 则最终的支付金额将增加那个微小值的 2.2 倍
链式法则（可以了解下复合函数的链式求导法则）
反向传播的计算顺序是，将信号 E 乘以节点的局部导数 ( )，然后将结果传递给下一个节点
复合函数链式求导法则，这里略。
链式法则和计算图
反向传播
加法节点的反向传播将上游的值原封不动地输出到下游
乘法的反向传播会乘以输入信号的翻转值
简单例子：
简单层的实现
乘法层的实现
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
例子：
# 正向传播
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 = None
def forward(self, x):
# 根据是否x<=0将x数组转化成True/False数组
self.mask = (x <= 0)
out = x.copy()
# 是True的也就是x<=0的就输出0，其他的不变
out[self.mask] = 0
return out
def backward(self, dout):
# 若为true则表示x<=0此时输出0 其他的不变
dout[self.mask] = 0
dx = dout
return dx
Sigmoid 层
表达式、计算图
其中一些注意的地方：
- “/”节点表示 y = 1/x，它的导数表达式为：
- “exp”节点表示y = exp(x)，导数仍为exp(x)
- 反向的输出结果可以进行简化推导：
可以得到完整的计算图为：
简化为：
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
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 = None
def forward(self, x):
self.x = x
out = np.dot(x, self.W) + self.b
return out
def 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 = 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]
# 批的大小(batch_size)
dx = (self.y - self.t) / batch_size
return 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)
# 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
误差反向传播法的梯度确认
确认数值 微分求出的梯度结果和误差反向传播法求出的结果是否一致(严格地讲，是 非常相近)的操作称为梯度确认(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)
小结
• 通过使用计算图，可以直观地把握计算过程。
• 计算图的节点是由局部计算构成的。局部计算构成全局计算。
• 计算图的正向传播进行一般的计算。通过计算图的反向传播，可以计算各个节点的导数。
• 通过将神经网络的组成元素实现为层，可以高效地计算梯度(反向传播法)。
• 通过比较数值微分和误差反向传播法的结果，可以确认误差反向传播法的实现是否正确(梯度确认)。
8309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
