误差逆传播算法（BP算法）
本文内容主要参考《机器学习》（清华大学出版社，西瓜书）
1. 算法思想
给定训练集 D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , … , ( x m , y m ) } , x i ∈ R d , y i ∈ R l D=\{(\pmb{x}_1, \pmb{y}_1), (\pmb{x}_2, \pmb{y}_2), \dots, (\pmb{x}_m, \pmb{y}_m)\},\pmb{x}_i \in R^{d}, \pmb{y}_i \in R^l D={(xxx1,yyy1),(xxx2,yyy2),…,(xxxm,yyym)},xxxi∈Rd,yyyi∈Rl，即训练集中一共有 m m m个训练数据，每个数据的输入由 d d d个属性描述，输出为 l l l维实值向量。
在下文的神经网络中采用的神经元模型都是上图所示的“M-P神经元模型”。
上图给出了一个拥有** d d d个输入神经元， q q q个隐层神经元， l l l个输出神经元**的多层前馈神经网络结构。
其中，输出层第 j j j个神经元的阈值用 θ j \theta_j θj表示，隐层第 h h h个神经元的阈值用 γ h \gamma_h γh表示。输入层第 i i i个神经元与隐层第 h h h个神经元之间的连接权为 v i h v_{ih} vih，隐层第 h h h个神经元与输出层第 j j j个神经元之间的连接权为 w h j w_{hj} whj。
记隐层第 h h h个神经元接收到的输入是 α h = ∑ i = 1 d v i h x i \alpha_h=\sum_{i=1}^{d}v_{ih}x_i αh=∑i=1dvihxi，输出层第 j j j个神经元接收到的输入是 β j = ∑ h = 1 q w h j b h \beta_j=\sum_{h=1}^{q}w_{hj}b_h βj=∑h=1qwhjbh，其中 b h b_h bh是隐层第 h h h个神经元的输出。假设隐层和输出层神经元都是用 S i g m o i d Sigmoid Sigmoid函数（ s i g m o i d ( x ) = 1 1 + e − x sigmoid(x)=\frac{1}{1+e^{-x}} sigmoid(x)=1+e−x1）。
对训练例
(
x
k
,
y
k
)
(\pmb{x}_k, \pmb{y}_k)
(xxxk,yyyk)，假定神经网络的输出为
y
^
k
=
(
y
^
1
k
,
y
^
2
k
,
…
,
y
^
l
k
)
\hat{\pmb{y}}_k=(\hat{y}_1^k,\hat{y}_2^k,\dots,\hat{y}_l^k)
yyy^k=(y^1k,y^2k,…,y^lk)，即
式
1
:
y
^
j
k
=
s
i
g
m
o
i
d
(
β
j
−
θ
j
)
,
式1:\ \hat{y}_j^k=sigmoid(\beta_j-\theta_j),
式1: y^jk=sigmoid(βj−θj),
则网络在
(
x
k
,
y
k
)
(\pmb{x}_k, \pmb{y}_k)
(xxxk,yyyk)上的均方误差为
式
2
:
E
k
=
1
2
∑
j
=
1
l
(
y
^
j
k
−
y
j
k
)
2
.
式2:\ E_k=\frac{1}{2}\sum_{j=1}^l(\hat{y}_j^k-y_j^k)^2.
式2: Ek=21j=1∑l(y^jk−yjk)2.
这里是整理的符号表：
| 符号名 | 符号含义 |
|---|---|
| d d d | 输入神经元个数 |
| q q q | 隐层神经元个数 |
| l l l | 输出神经元个数 |
| γ h \gamma_h γh | 隐层第 h h h个神经元的阈值 |
| θ j \theta_j θj | 输出层第 j j j个神经元的阈值 |
| v i h v_{ih} vih | 输入层第 i i i个神经元与隐层第 h h h个神经元的之间连接权 |
| w h j w_{hj} whj | 隐层第 h h h个神经元与输出层第 j j j个神经元之间的连接权 |
| α h \alpha_h αh | 隐层第 h h h个神经元接收到的输入 |
| b h b_h bh | 隐层第 h h h个神经元的输出 |
| β j \beta_j βj | 输出层第 j j j个神经元接收到的输入 |
| y ^ j k \hat{y}_j^k y^jk | 输出层第 j j j个神经元的输出 |
网络中有
(
d
+
1
)
∗
q
+
(
q
+
1
)
∗
l
(d+1)*q+(q+1)*l
(d+1)∗q+(q+1)∗l个参数需要确定：输入层到隐层的
d
∗
q
d*q
d∗q个权值，
q
q
q个隐层神经元的阈值，隐层到输出层的
q
∗
l
q*l
q∗l个权值，
l
l
l个输出神经元的阈值。BP（BackPropagation）是一个迭代学习算法，在迭代的每一轮中采用广义的感知机学习规则对参数进行更新估计，任意参数
v
v
v的更新估计式为
式
3
:
v
←
v
+
Δ
v
.
式3:\ v \leftarrow v+\Delta v.
式3: v←v+Δv.
下面我们以神经网络图中的隐层到输出层的连接权
w
h
j
w_{hj}
whj为例来进行推导。
BP算法基于梯度下降策略，以目标的负梯度方向对参数进行调整。对误差
E
k
E_k
Ek，给定学习率
η
\eta
η，有
式
4
:
Δ
w
h
j
=
−
η
∂
E
k
∂
w
h
j
.
式4:\ \Delta w_{hj}=-\eta \frac{\partial E_k}{\partial w_{hj}}.
式4: Δwhj=−η∂whj∂Ek.
注意到
w
h
j
w_{hj}
whj先影响到输出层第
j
j
j个神经元的输入值
β
j
\beta_j
βj，再影响到其输出值
y
^
j
k
\hat{y}_j^k
y^jk，最后影响到
E
k
E_k
Ek，有
式
5
:
∂
E
k
∂
w
h
j
=
∂
E
k
∂
y
^
j
k
∗
∂
y
^
j
k
∂
β
j
∗
∂
β
j
∂
w
h
j
.
式5:\ \frac{\partial E_k}{\partial w_{hj}}=\frac{\partial E_k}{\partial \hat{y}_j^k}*\frac{\partial \hat{y}_j^k}{\partial \beta_j}*\frac{\partial \beta_j}{\partial w_{hj}}.
式5: ∂whj∂Ek=∂y^jk∂Ek∗∂βj∂y^jk∗∂whj∂βj.
根据
β
j
\beta_j
βj的定义，显然有
式
6
:
∂
β
j
∂
w
h
j
=
b
h
.
式6:\ \frac{\partial \beta_j}{\partial w_{hj}}=b_h.
式6: ∂whj∂βj=bh.
S
i
g
m
o
i
d
Sigmoid
Sigmoid函数有一个很好的性质：
式
7
:
s
i
g
m
o
i
d
′
(
x
)
=
s
i
g
m
o
i
d
(
x
)
∗
(
1
−
s
i
g
m
o
i
d
(
x
)
)
.
式7:\ sigmoid'(x)=sigmoid(x)*(1-sigmoid(x)).
式7: sigmoid′(x)=sigmoid(x)∗(1−sigmoid(x)).
于是根据式2和式1，
式
8
:
g
j
=
−
∂
E
k
∂
y
^
j
k
∗
∂
y
^
j
k
∂
β
j
=
−
(
y
^
j
k
−
y
j
k
)
s
i
g
m
o
i
d
′
(
β
j
−
θ
j
)
=
y
^
j
k
(
1
−
y
^
j
k
)
(
y
j
k
−
y
^
j
k
)
式8:\ g_j=-\frac{\partial E_k}{\partial \hat{y}_j^k}*\frac{\partial \hat{y}_j^k}{\partial \beta_j}\\ =-(\hat{y}_j^k-y_j^k)sigmoid'(\beta_j-\theta_j)\\ =\hat{y}_j^k(1-\hat{y}_j^k)(y_j^k-\hat{y}_j^k)
式8: gj=−∂y^jk∂Ek∗∂βj∂y^jk=−(y^jk−yjk)sigmoid′(βj−θj)=y^jk(1−y^jk)(yjk−y^jk)
将式8和式6代入式5，再代入式4，就得到了BP算法中关于
w
h
j
w_{hj}
whj的更新公式
式
9
:
Δ
w
h
j
=
η
∗
g
j
∗
b
h
.
式9:\ \Delta w_{hj}=\eta * g_j * b_h.
式9: Δwhj=η∗gj∗bh.
类似可得
式
10
:
Δ
θ
j
=
−
η
∂
E
k
∂
θ
j
=
−
η
∂
E
k
∂
y
^
j
k
∗
∂
y
^
j
k
∂
θ
j
=
−
η
(
y
^
j
k
−
y
j
k
)
s
i
g
m
o
i
d
′
(
β
j
−
θ
j
)
=
−
η
(
y
^
j
k
−
y
j
k
)
y
^
j
k
(
1
−
y
^
j
k
)
∗
−
1
=
−
η
g
j
,
式10:\ \Delta \theta_j=-\eta\frac{\partial E_k}{\partial \theta_j}=-\eta\frac{\partial E_k}{\partial \hat{y}_j^k}*\frac{\partial \hat{y}_j^k}{\partial \theta_j}\\ =-\eta(\hat{y}_j^k-y_j^k)sigmoid'(\beta_j-\theta_j)\\ =-\eta(\hat{y}_j^k-y_j^k)\hat{y}_j^k(1-\hat{y}_j^k)*-1=-\eta g_j,
式10: Δθj=−η∂θj∂Ek=−η∂y^jk∂Ek∗∂θj∂y^jk=−η(y^jk−yjk)sigmoid′(βj−θj)=−η(y^jk−yjk)y^jk(1−y^jk)∗−1=−ηgj,
式 11 : Δ v i h = η e h x i , 式11:\ \Delta v_{ih}=\eta e_h x_i, 式11: Δvih=ηehxi,
式 12 : Δ γ h = − η e h ， 式12:\ \Delta\gamma_h=-\eta e_h， 式12: Δγh=−ηeh，
在式11和式12中，
式
13
:
e
h
=
−
∂
E
k
∂
b
h
∗
∂
b
h
∂
α
h
=
−
∑
j
=
1
l
∂
E
k
∂
β
j
∗
∂
β
j
∂
α
h
s
i
g
m
o
i
d
′
(
α
h
−
γ
h
)
=
∑
j
=
1
l
g
j
w
h
j
s
i
g
m
o
i
d
′
(
α
h
−
γ
h
)
=
b
h
(
1
−
b
h
)
∑
j
=
1
l
g
j
w
h
j
.
式13:\ e_h=-\frac{\partial E_k}{\partial b_h}*\frac{\partial b_h}{\partial \alpha_h}\\ =-\sum_{j=1}^{l}\frac{\partial E_k}{\partial \beta_j}*\frac{\partial \beta_j}{\partial \alpha_h}sigmoid'(\alpha_h-\gamma_h)\\ =\sum_{j=1}^{l}g_jw_{hj}sigmoid'(\alpha_h-\gamma_h)\\ =b_h(1-b_h)\sum_{j=1}^{l}g_jw_{hj}.
式13: eh=−∂bh∂Ek∗∂αh∂bh=−j=1∑l∂βj∂Ek∗∂αh∂βjsigmoid′(αh−γh)=j=1∑lgjwhjsigmoid′(αh−γh)=bh(1−bh)j=1∑lgjwhj.
学习率
η
\eta
η控制着算法每一轮迭代中的更新步长，若太大则容易振荡，太小则收敛速度又会过慢。有时为了精细调节，式9和式10使用
η
1
\eta_1
η1，式11和式12使用
η
2
\eta_2
η2，两者未必相等。
2. 伪代码
对每个训练样例，BP算法执行以下操作：
先将输入示例提供给输入层神经元，然后逐层将信号前传，直到产生输出层的结果；然后计算输出层的误差（第4-5行），再将误差逆向传播至隐层神经元（第6行），最后根据隐层神经元的误差来对连接权和阈值进行调整（第7行）。该迭代过程循环进行，直到达到某些停止条件为止。
输入: 训练集D; 学习率lr
过程:
1: 在(0, 1)范围内随机初始化网络中所有连接权和阈值
2: repeat
3: for all (x_k, y_k) ∈ D do
4: 根据当前参数和式1计算当前样本的输出y_hat_k;
5: 根据式8计算输出层神经元的梯度项g_j;
6: 根据式13计算隐层神经元的梯度向e_h;
7: 根据式9-12更新连接权w_hj, v_ih与阈值theta_j与gamma_h
8: end for
9: until 达到停止条件
输出: 连接权与阈值确定的多层前馈神经网络
3. 累积误差
BP算法的目标是要最小化训练集
D
D
D上的累计误差
E
=
1
m
∑
k
=
1
m
E
k
,
E=\frac{1}{m}\sum_{k=1}^{m}E_k,
E=m1k=1∑mEk,
之前介绍的都是每次仅针对一个训练样例更新连接权和阈值的标准BP算法，也就是说上述算法的更新规则是基于单个的
E
k
E_k
Ek推导而得的。如果类似地推导出基于累积误差最小化的更新规则，就得到了累积误差逆传播算法。
一般来说，标准BP算法每次更新只针对单个样例，参数更新得非常频繁，而且对不同样例进行更新的效果可能出现“抵消”效果。因此为了达到同样的累积误差极小点，标准BP算法往往需要更多次数的迭代，累积BP算法直接针对累积误差最小化，它在读取整个训练集 D D D一遍（读取训练集一遍称为进行了一轮（one epoch）学习）后才对参数进行更新，其参数更新的频率低得多。但在很多任务中，累积误差下降到一定程度之后，进一步下降会非常缓慢，这是标准BP往往会更快得到较好的解，尤其是在训练集 D D D非常大时更加明显。
4. 实例
4.1 Numpy实现两层神经网络
一个全连接ReLU神经网络，一个隐藏层，没有bias（阈值为0，
γ
h
=
0
\gamma_h=0
γh=0，
θ
j
=
0
\theta_j=0
θj=0）。用来从
x
x
x预测
y
y
y，使用L2-Loss。
α
=
W
1
x
b
=
R
e
L
U
(
α
)
y
^
=
W
2
b
\alpha=W_1x\\ b=ReLU(\alpha)\\ \hat{y}=W_2b
α=W1xb=ReLU(α)y^=W2b
这一实现完全使用numpy来计算前向神经网络，loss和反向传播。
import numpy as np
m, d, p, l = 64, 1000, 100, 10
# 随机创建一些训练数据
x = np.random.randn(m, d)
y = np.random.randn(m, l)
# 随机初始化连接权
w1 = np.random.randn(d, p)
w2 = np.random.randn(p, l)
learning_rate = 1e-6
for it in range(500):
# forward pass
alpha = x.dot(w1) # m * p
b = np.maximum(alpha, 0) # m * p
y_hat = b.dot(w2) # m * l
# compute loss
loss = np.square(y_pred - y).sum()
print(it, loss)
# backward pass
# compute the gradient
grad_y_hat = 2.0 * (y_hat - y)
grad_w2 = b.T.dot(grad_y_hat)
grad_b = grad_y_hat.dot(w2.T)
grad_alpha = grad_b.copy()
grad_alpha[alpha < 0] = 0
grad_w1 = x.T.dot(grad_alpha)
# update weights of w1 and w2
w1 -= learning_rate * grad_w1
w2 -= learning_rate * grad_w2
4.2 PyTorch实现两层神经网络
4.2.1 手动grad
这里使用PyTorch实现的神经网络代码和Numpy实现的几乎没有区别，只是把Numpy的操作换成了PyTorch的操作。
import torch
m, d, p, l = 64, 1000, 100, 10
# 随机创建一些训练数据
x = torch.randn(m, d)
y = torch.randn(m, l)
# 随机初始化连接权
w1 = torch.randn(d, p)
w2 = torch.randn(p, l)
learning_rate = 1e-6
for it in range(500):
# forward pass
alpha = x.mm(w1) # m * p
b = alpha.clamp(min=0) # m * p
y_hat = b.mm(w2) # m * l
# compute loss
loss = (y_pred-y).pow(2).sum().item()
print(it, loss)
# backward pass
# compute the gradient
grad_y_hat = 2.0 * (y_hat - y)
grad_w2 = b.t().mm(grad_y_hat)
grad_b = grad_y_hat.mm(w2.t())
grad_alpha = grad_b.clone()
grad_alpha[alpha < 0] = 0
grad_w1 = x.t().mm(grad_alpha)
# update weights of w1 and w2
w1 -= learning_rate * grad_w1
w2 -= learning_rate * grad_w2
4.2.2 autograd
import torch
m, d, p, l = 64, 1000, 100, 10
# 随机创建一些训练数据
x = torch.randn(m, d)
y = torch.randn(m, l)
# 随机初始化连接权
w1 = torch.randn(d, p, requires_grad=True)
w2 = torch.randn(p, l, requires_grad=True)
learning_rate = 1e-6
for it in range(500):
# forward pass
y_hat = x.mm(w1).clamp(min=0).mm(w2)
# compute loss
loss = (y_pred-y).pow(2).sum() # computation graph
print(it, loss.item())
# backward pass
loss.backward()
# update weights of w1 and w2
with torch.no_grad():
w1 -= learning_rate * w1.grad
w2 -= learning_rate * w2.grad
w1.grad.zero_()
w2.grad.zero_()
4.2.3 nn库
import torch
import torch.nn as nn
m, d, p, l = 64, 1000, 100, 10
# 随机创建一些训练数据
x = torch.randn(m, d)
y = torch.randn(m, l)
model = torch.nn.Sequential(
torch.nn.Linear(d, p),
torch.nn.ReLU(),
torch.nn.Linear(p, l)
)
torch.nn.init.normal_(model[0].weight)
torch.nn.init.normal_(model[2].weight)
# model = model.cuda()
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-6
for it in range(500):
# forward pass
y_hat = model(x)
# compute loss
loss = loss_fn(y_pred, y) # computation graph
print(it, loss.item())
# backward pass
loss.backward()
# update weights of w1 and w2
with torch.no_grad():
for param in model.parameters():
param -= learning_rate * param.grad
model.zero_grad()
4.2.4 使用optim
使用optim包来更新参数，optim这个包提供了各种不同的模型优化方法，包括SGD+momentum, RMSProp, Adam等等。
import torch
import torch.nn as nn
m, d, p, l = 64, 1000, 100, 10
# 随机创建一些训练数据
x = torch.randn(m, d)
y = torch.randn(m, l)
model = torch.nn.Sequential(
torch.nn.Linear(d, p),
torch.nn.ReLU(),
torch.nn.Linear(p, l)
)
# model = model.cuda()
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-4
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
for it in range(500):
# forward pass
y_hat = model(x)
# compute loss
loss = loss_fn(y_pred, y) # computation graph
print(it, loss.item())
optimizer.zero_grad()
# backward pass
loss.backward()
# update model parameters
optimizer.step()
4.2.5 自定义nn Modules
定义一个模型，这个模型继承自nn.Modules。如果需要定义一个比Sequential模型更加复杂的模型，就需要定义nn.Modules模型。
import torch
import torch.nn as nn
m, d, p, l = 64, 1000, 100, 10
# 随机创建一些训练数据
x = torch.randn(m, d)
y = torch.randn(m, l)
class TwoLayersNet(torch.nn.Module):
def __init__(self, d, p, l):
super(TwoLayerNet, self).__init__()
# define the model architecture
self.linear1 = torch.nn.Linear(d, p)
self.linear2 = torch.nn.Linear(p, l)
def forward(self, x):
y_pred = self.linear2(self.linear1(x).clamp(min=0))
return y_pred
model = TwoLayersNet(d, p, l)
# model = model.cuda()
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-4
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
for it in range(500):
# forward pass
y_hat = model(x) # 调用model.forward(x)
# compute loss
loss = loss_fn(y_pred, y) # computation graph
print(it, loss.item())
optimizer.zero_grad()
# backward pass
loss.backward()
# update model parameters
optimizer.step()
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
