NNDL 作业10 BPTT

习题6-1P 推导RNN反向传播算法BPTT.

关于这道题的公式推导，我参考了哔哩哔哩上大佬的讲解，链接如下：

循环神经网络讲解｜随时间反向传播推导(BPTT)｜RNN梯度爆炸和梯度消失的原因｜LSTM及GRU(解决RNN中的梯度爆炸和梯度消失)-跟李沐老师动手学深度学习_哔哩哔哩_bilibili

部分理论知识： 

        BPTT（back-propagation through time）本质还是BP算法，只不过RNN处理时间序列数据，所以要基于时间反向传播，故叫随时间反向传播。BPTT的中心思想和BP算法相同，沿着需要优化的参数的负梯度方向不断寻找更优的点直至收敛。综上所述，BPTT算法本质还是BP算法，BP算法本质还是梯度下降法，那么求各个参数的梯度便成了此算法的核心。

(出处：循环神经网络(RNN)模型与前向反向传播算法 - 刘建平Pinard - 博客园 (cnblogs.com)）

 以长度为3的RNN反向传播算法BPTT为例进行推导：

分别计算t=3时刻损失值对V，W，U的偏导

 由计算出的t=3时刻的偏导推出一般公式：

 由公式中的连乘部分可以说明梯度消失和梯度爆炸原理：

习题6-2 推导公式(6.40)和公式(6.41)中的梯度．

在第一问中，我已经推导出了公式（6.40），这里仅推导公式（6.41）：

习题6-3 当使用公式(6.50)作为循环神经网络的状态更新公式时， 分析其可能存在梯度爆炸的原因并给出解决方法．

       若使用zk = Uhk-1 + Wxk + b 作为k时刻g(·)的输入，那么在对其求导时，ht与ht-1的权重系数就会超过1.

用公式进行详细解释：（[2022-11-28]神经网络与深度学习 hw10 - LSTM和GRU-CSDN博客）

解决办法：其一是简单的使用梯度截断方式，暴力高效；另一个是增加门控装置，避免产生这类现象。

习题6-2P 设计简单RNN模型，分别用Numpy、Pytorch实现反向传播算子，并代入数值测试.

1. 定义反向求导函数：

import numpy as np
import torch.nn
 
# GRADED FUNCTION: rnn_cell_forward
def softmax(a):
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y
 
 
def rnn_cell_forward(xt, a_prev, parameters):
 
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]
 
    a_next = np.tanh(np.dot(Wax, xt) + np.dot(Waa, a_prev) + ba)
    yt_pred = softmax(np.dot(Wya, a_next) + by)
    cache = (a_next, a_prev, xt, parameters)
    
    return a_next, yt_pred, cache
 
def rnn_cell_backward(da_next, cache):
 
    (a_next, a_prev, xt, parameters) = cache
 
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]
 
    dtanh = (1 - a_next * a_next) * da_next 
 
    dxt = np.dot(Wax.T, dtanh)
    dWax = np.dot(dtanh, xt.T)
 
    da_prev = np.dot(Waa.T, dtanh)
    dWaa = np.dot(dtanh, a_prev.T)
 
    dba = np.sum(dtanh, keepdims=True, axis=-1)  
 
 
    gradients = {"dxt": dxt, "da_prev": da_prev, "dWax": dWax, "dWaa": dWaa, "dba": dba}
 
    return gradients
 
 
# GRADED FUNCTION: rnn_forward
np.random.seed(1)
xt = np.random.randn(3, 10)
a_prev = np.random.randn(5, 10)
Wax = np.random.randn(5, 3)
Waa = np.random.randn(5, 5)
Wya = np.random.randn(2, 5)
ba = np.random.randn(5, 1)
by = np.random.randn(2, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "ba": ba, "by": by}
 
a_next, yt, cache = rnn_cell_forward(xt, a_prev, parameters)
 
da_next = np.random.randn(5, 10)
gradients = rnn_cell_backward(da_next, cache)
print("gradients[\"dxt\"][1][2] =", gradients["dxt"][1][2])
print("gradients[\"dxt\"].shape =", gradients["dxt"].shape)
print("gradients[\"da_prev\"][2][3] =", gradients["da_prev"][2][3])
print("gradients[\"da_prev\"].shape =", gradients["da_prev"].shape)
print("gradients[\"dWax\"][3][1] =", gradients["dWax"][3][1])
print("gradients[\"dWax\"].shape =", gradients["dWax"].shape)
print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2])
print("gradients[\"dWaa\"].shape =", gradients["dWaa"].shape)
print("gradients[\"dba\"][4] =", gradients["dba"][4])
print("gradients[\"dba\"].shape =", gradients["dba"].shape)
gradients["dxt"][1][2] = -0.4605641030588796
gradients["dxt"].shape = (3, 10)
gradients["da_prev"][2][3] = 0.08429686538067724
gradients["da_prev"].shape = (5, 10)
gradients["dWax"][3][1] = 0.39308187392193034
gradients["dWax"].shape = (5, 3)
gradients["dWaa"][1][2] = -0.28483955786960663
gradients["dWaa"].shape = (5, 5)
gradients["dba"][4] = [0.80517166]
gradients["dba"].shape = (5, 1)

2. 实现反向传播函数。

# GRADED FUNCTION: rnn_forward
def rnn_forward(x, a0, parameters):
 
    caches = []
    n_x, m, T_x = x.shape
    n_y, n_a = parameters["Wya"].shape
 
    a = np.zeros((n_a, m, T_x))
    y_pred = np.zeros((n_y, m, T_x))
 
    a_next = a0
 
    for t in range(T_x):
 
        a_next, yt_pred, cache = rnn_cell_forward(x[:, :, t], a_next, parameters)
        a[:, :, t] = a_next
        y_pred[:, :, t] = yt_pred
        caches.append(cache)
 
    caches = (caches, x)
 
    return a, y_pred, caches
 
 
np.random.seed(1)
x = np.random.randn(3, 10, 4)
a0 = np.random.randn(5, 10)
Waa = np.random.randn(5, 5)
Wax = np.random.randn(5, 3)
Wya = np.random.randn(2, 5)
ba = np.random.randn(5, 1)
by = np.random.randn(2, 1)
parameters = {"Waa": Waa, "Wax": Wax, "Wya": Wya, "ba": ba, "by": by}
 
a, y_pred, caches = rnn_forward(x, a0, parameters)
print("a[4][1] = ", a[4][1])
print("a.shape = ", a.shape)
print("y_pred[1][3] =", y_pred[1][3])
print("y_pred.shape = ", y_pred.shape)
print("caches[1][1][3] =", caches[1][1][3])
print("len(caches) = ", len(caches))

3.  分别用numpy和pytorh实现反向传播算子 

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("tensor_hidden :\n", h3_tensor[0].data.numpy())
    print("------")
 
    print("dx_numpy :\n", np.array(rnn_numpy.dx_list))
    print("dx_tensor :\n", x3_tensor.grad.data.numpy())
    print("------")
 
    print("dw_ih_numpy :\n",
          np.sum(rnn_numpy.dw_ih_stack, axis=0))
    print("dw_ih_tensor :\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_tensor :\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_tensor :\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_tensor :\n",
          rnn_PyTorch.all_weights[0][3].grad.data.numpy())

 代码实现参考HBU-NNDL 作业9：分别使用numpy和pytorch实现BPTT_哦n........yly hbu: 9-CSDN博客和L5W1作业1 手把手实现循环神经网络-CSDN博客进行实现

总结+补充：

1. 增加门控机制，这里介绍长短期记忆网络LSTM：（这里暂时还没讲到，我在网上进行搜索）

（附出处：循环神经网络（内含LSTM、GRU实战）_simplernn实例-CSDN博客）

   相比传统的CNN来说，LSTM更擅长于处理长时间的记忆。

        LSTM的原理：

​

与RNN的区别：

         1. 除了输入的xt和ht-1之外，还加入了一个长时记忆单元c，而h控制的是一个短时的记忆。 

         2. 还有门控机制：输入门、遗忘门、输出门，通过三个门来控制信息的流转。

---

  门控机制：

​

         输出有多少取决于门控值！我们称门控程度为：门控值，其可以控制阈值。首先把门控值压缩到（0，1）之间，当sigmoid输出为0时是完全关闭，1时是完全打开。

2. 公式推导部分

公式推导部分我参考的是舍友今天也是元气满满的一天呢推荐的哔哩哔哩上的视频：

循环神经网络讲解｜随时间反向传播推导(BPTT)｜RNN梯度爆炸和梯度消失的原因｜LSTM及GRU(解决RNN中的梯度爆炸和梯度消失)-跟李沐老师动手学深度学习_哔哩哔哩_bilibili

视频讲解思路很清晰，讲解了公式推导过程和梯度爆炸，梯度消失的原因及解决方法，听完之后等于复习了一遍知识点，强推！！！

3. BPTT与BP算法的不同

        RNN的参数都是共享的，而且某时刻的梯度是此时刻和之前时刻的累加，即使传不到最深处那浅层也是有梯度的。但是如果根据有限层的梯度来更新更多层的共享的参数一定会出现问题的，因为将有限的信息来作为寻优根据必定不会找到所有信息的最优解。

4. 对于LSTM可以缓解梯度消失的解释

        第三问中，使用门控机制的解决方法其中一种就是LSTM，我看了原理图，发现不是很明白，为什么LSTM可以缓解梯度消失问题，以下是解答：

（为什么LSTM可以缓解梯度消失？_lstm为什么能解决梯度消失-CSDN博客）

依靠学习得到权值去控制依赖的长度，这便是LSTM缓解梯度消失的真相。可以总结为两点：

   1、cell state传播函数中的“加法”结构确实起了一定作用，它使得导数有可能大于1；
   2、LSTM中逻辑门的参数可以一定程度控制不同时间步梯度消失的程度。

  LSTM依然不能完全解决梯度消失这个问题，只可以缓解。有文献表示序列长度一般到了三百多仍然会出现梯度消失现象。如果想彻底规避这个问题，还是transformer更好用一些。