习题6-1P 推导RNN反向传播算法BPTT.
数学 · RNN(二)· BPTT 算法 - 知乎 (zhihu.com)
RNN与其反向传播算法——BPTT(Backward Propogation Through Time)的详细推导_bptt算法推导-CSDN博客
-
初始化参数:对RNN模型的参数进行初始化。
-
前向传播计算隐藏状态:从输入序列的第一个时间步开始,逐步计算每个时间步的隐藏状态。隐藏状态是RNN模型中的关键部分,它通过将当前时间步的输入与前一个时间步的隐藏状态进行计算,来传递信息并捕捉序列中的上下文信息。
-
前向传播计算输出:基于每个时间步的隐藏状态,计算当前时间步的输出。
-
计算损失:将模型预测的输出与真实标签进行比较,计算损失函数来衡量模型预测的准确程度。
-
反向传播计算梯度:根据损失函数的值,利用链式法则从最后一个时间步开始,逐步计算每个时间步的参数梯度。
-
反向传播计算隐藏状态梯度:利用输出层的梯度和后续时间步的隐藏状态梯度,逐步计算每个时间步的隐藏状态梯度。
-
反向传播计算输入梯度:利用隐藏状态梯度和输入序列,逐步计算每个时间步的输入梯度。
-
参数更新:根据计算得到的梯度,使用优化算法来更新模型的参数,使得损失函数逐渐减小。
对矩阵V的分析过程即为普通的反向传播算法,相对而言比较平凡。总梯度可以表示为:
而事实上,RNN 的 BP 算法的主要难点在于它 State 之间的通信,亦即梯度除了按照空间结构传播以外,还得沿着时间通道传播,这导致我们比较难将相应 RNN 的 BP 算法写成一个统一的形式。为此,我们可以采用“循环”的方法来计算各个梯度。
由于是反向传播算法,所以t应从n开始降序循环至 1,在此期间(若需要初始化、则初始化为 0 向量或 0 矩阵):
- 计算时间通道上的“局部梯度” :
- 利用时间通道上的“局部梯度”计算U和W的梯度:
习题6-2 推导公式(6.40)和公式(6.41)中的梯度.
习题6-3 当使用公式(6.50)作为循环神经网络的状态更新公式时, 分析其可能存在梯度爆炸的原因并给出解决方法.
梯度可能因为权重矩阵Whh的特征值大于1,非线性地迅速增大,出现梯度爆炸. 这种情况较好处理,设置梯度截断阈值,在反向传播过程中,如果梯度的范数超过了一个特定的阈值,就将梯度裁剪到该阈值以下。
习题6-2P 设计简单RNN模型,分别用Numpy、Pytorch实现反向传播算子,并代入数值测试.
import torch
import numpy as np
class RNNCell:
def __init__(self, weight_ih, weight_hh,
bias_ih, bias_hh):
self.weight_ih = weight_ih
self.weight_hh = weight_hh
self.bias_ih = bias_ih
self.bias_hh = bias_hh
self.x_stack = []
self.dx_list = []
self.dw_ih_stack = []
self.dw_hh_stack = []
self.db_ih_stack = []
self.db_hh_stack = []
self.prev_hidden_stack = []
self.next_hidden_stack = []
# temporary cache
self.prev_dh = None
def __call__(self, x, prev_hidden):
self.x_stack.append(x)
next_h = np.tanh(
np.dot(x, self.weight_ih.T)
+ np.dot(prev_hidden, self.weight_hh.T)
+ self.bias_ih + self.bias_hh)
self.prev_hidden_stack.append(prev_hidden)
self.next_hidden_stack.append(next_h)
# clean cache
self.prev_dh = np.zeros(next_h.shape)
return next_h
def backward(self, dh):
x = self.x_stack.pop()
prev_hidden = self.prev_hidden_stack.pop()
next_hidden = self.next_hidden_stack.pop()
d_tanh = (dh + self.prev_dh) * (1 - next_hidden ** 2)
self.prev_dh = np.dot(d_tanh, self.weight_hh)
dx = np.dot(d_tanh, self.weight_ih)
self.dx_list.insert(0, dx)
dw_ih = np.dot(d_tanh.T, x)
self.dw_ih_stack.append(dw_ih)
dw_hh = np.dot(d_tanh.T, prev_hidden)
self.dw_hh_stack.append(dw_hh)
self.db_ih_stack.append(d_tanh)
self.db_hh_stack.append(d_tanh)
return self.dx_list
if __name__ == '__main__':
np.random.seed(123)
torch.random.manual_seed(123)
np.set_printoptions(precision=6, suppress=True)
rnn_PyTorch = torch.nn.RNN(4, 5).double()
rnn_numpy = RNNCell(rnn_PyTorch.all_weights[0][0].data.numpy(),
rnn_PyTorch.all_weights[0][1].data.numpy(),
rnn_PyTorch.all_weights[0][2].data.numpy(),
rnn_PyTorch.all_weights[0][3].data.numpy())
nums = 3
x3_numpy = np.random.random((nums, 3, 4))
x3_tensor = torch.tensor(x3_numpy, requires_grad=True)
h3_numpy = np.random.random((1, 3, 5))
h3_tensor = torch.tensor(h3_numpy, requires_grad=True)
dh_numpy = np.random.random((nums, 3, 5))
dh_tensor = torch.tensor(dh_numpy, requires_grad=True)
h3_tensor = rnn_PyTorch(x3_tensor, h3_tensor)
h_numpy_list = []
h_numpy = h3_numpy[0]
for i in range(nums):
h_numpy = rnn_numpy(x3_numpy[i], h_numpy)
h_numpy_list.append(h_numpy)
h3_tensor[0].backward(dh_tensor)
for i in reversed(range(nums)):
rnn_numpy.backward(dh_numpy[i])
print("numpy_hidden :\n", np.array(h_numpy_list))
print("torch_hidden :\n", h3_tensor[0].data.numpy())
print("-----------------------------------------------")
print("dx_numpy :\n", np.array(rnn_numpy.dx_list))
print("dx_torch :\n", x3_tensor.grad.data.numpy())
print("------------------------------------------------")
print("dw_ih_numpy :\n",
np.sum(rnn_numpy.dw_ih_stack, axis=0))
print("dw_ih_torch :\n",
rnn_PyTorch.all_weights[0][0].grad.data.numpy())
print("------------------------------------------------")
print("dw_hh_numpy :\n",
np.sum(rnn_numpy.dw_hh_stack, axis=0))
print("dw_hh_torch :\n",
rnn_PyTorch.all_weights[0][1].grad.data.numpy())
print("------------------------------------------------")
print("db_ih_numpy :\n",
np.sum(rnn_numpy.db_ih_stack, axis=(0, 1)))
print("db_ih_torch :\n",
rnn_PyTorch.all_weights[0][2].grad.data.numpy())
print("-----------------------------------------------")
print("db_hh_numpy :\n",
np.sum(rnn_numpy.db_hh_stack, axis=(0, 1)))
print("db_hh_torch :\n",
rnn_PyTorch.all_weights[0][3].grad.data.numpy())
代码实现
REF:L5W1作业1 手把手实现循环神经网络_追寻远方的人的博客-CSDN博客
LSTM的正向传播
1.2 RNN正向传播
你可以将RNN视为刚刚构建的单元的重复。如果输入的数据序列经过10个时间步长,则将复制RNN单元10次。每个单元格都将前一个单元格(a 〈 t − 1 〉 a^{\langle t-1 \rangle}a〈t−1〉)的隐藏状态和当前时间步的输入数据(x 〈 t 〉 x^{\langle t \rangle}x〈t〉)作为输入,并为此时间步输出隐藏状态(a 〈 t 〉 a^{\langle t \rangle}a〈t〉) 和预测(y 〈 t 〉 y^{\langle t \rangle}y〈t〉)。
图3:
练习:编码实现图(3)中描述的RNN的正向传播。
说明:
- 创建一个零向量(a),该向量将存储RNN计算的所有隐藏状态。
- 将“下一个”隐藏状态初始化为a 0(初始隐藏状态)。
- 开始遍历每个时间步,增量索引为t:
- 通过运行rnn_step_forward更新“下一个”隐藏状态和缓存。
- 将“下一个”隐藏状态存储在a中(t^{th}位置)
- 将预测存储在y中
- 将缓存添加到缓存列表中
- 返回a,y和缓存