7. 吴恩达深度学习--搭建循环神经网络及其应用

本文主要参考了 严宽 大神的学习笔记，并在其基础上补充了一点内容，点此查看原文。

一、搭建循环神经网络

循环神经网络（RNN）对于自然语言处理和其他序列任务非常有效，因为它们具有”记忆“功能。它们可以一次读取一个输入 $x^{(t)}$（如单词），并且通过隐藏层激活从一个时间步传递到下一个时间步来记住一些信息/上下文，这允许单向RNN从过去获取信息来处理后面的输入，双向RNN可以从过去和未来中获取上下文。

声明：

• 上标 $[l]$ 表示第 $l$ 层。eg：$a^{[l]}$ 表示第 4 层的激活值
• 上标 $(i)$ 表示第 $I$ 个样本。eg：$x^{[i]}$ 表示第 $i$ 个输入样本
• 上标 $<t>$ 表示第 $t$ 个时间步。eg：$x^{<t>}$ 表示输入 $x$ 的第 $t$ 个时间步
• 下标 $i$ 表示向量的第 $i$ 项。eg：$a_i^{[l]}$ 表示第 $l$ 层中的第 $i$ 个项的激活值

加载需要的库：

import numpy as np
import rnn_utils
1
2

1. 循环神经网络的前向传播

我们来看一下下面的循环神经网络的图，在这里使用的是 $T_x=T_y$，我们来实现它：

我们要实现它要有一下步骤：

1. 实现 RNN 的一个时间步所需要计算的东西
2. 在 $T_x$ 时间步上实现一个循环，以便一次处理所有输入。

（1）RNN 单元

循环神经网络可以看作是单元的重复，首先要实现单个时间步的计算，下图描述了 RNN 单元的单个时间步的操作。

现在我们要根据上图来实现一个 RNN 单元，需要实现以下步骤：

1. 使用 tanh 函数计算隐藏单元的激活值：$a^{<t>}=tanh(W_{aa}{a}^{<t-1>}+W_{ax}{x}^{<t>}+b_a)$
2. 使用 $a^{<t>}$ 计算 $\widehat{y^{<t>}}=softmax(W_{ya}{a}^{<t>}+b_y)$，softmax 在 rnn_utils 内
3. 把 $(a^{<t>},a^{<t-1>},x^{<t>},parameters)$ 存储到 $cache$ 中
4. 返回 $a^{<t>},y^{<t>}$ 与 $cache$

# 神经单元的前向传播
def rnn_cell_forward(xt, a_prev, parameters):
    """
    根据上图实现RNN单元的单步前向传播
    
    参数：
        xt -- 时间步“t”输入的数据，维度为（n_x, m）
        a_prev -- 时间步“t - 1”的隐藏隐藏状态，维度为（n_a, m）
        parameters -- 字典，包含了以下内容:
                        Wax -- 矩阵，输入乘以权重，维度为（n_a, n_x）
                        Waa -- 矩阵，隐藏状态乘以权重，维度为（n_a, n_a）
                        Wya -- 矩阵，隐藏状态与输出相关的权重矩阵，维度为（n_y, n_a）
                        ba  -- 偏置，维度为（n_a, 1）
                        by  -- 偏置，隐藏状态与输出相关的偏置，维度为（n_y, 1）
    
    返回：
        a_next -- 下一个隐藏状态，维度为（n_a， m）
        yt_pred -- 在时间步“t”的预测，维度为（n_y， m）
        cache -- 反向传播需要的元组，包含了(a_next, a_prev, xt, parameters)
    """
    # 从 parameters 获取参数
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]
    
    # 使用上面的公式计算当前单元的输出
    a_next = np.tanh(np.dot(Waa, a_prev) + np.dot(Wax, xt) + ba)
    
    # 使用上面的公式计算当前单元的输出
    yt_pred = rnn_utils.softmax(np.dot(Wya, a_next) + by)
    
    # 保存反向传播需要的值
    cache = (a_next, a_prev, xt, parameters)
    
    return a_next, yt_pred, cache
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

测试：

np.random.seed(1)
xt = np.random.randn(3,10)
a_prev = 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_next, yt_pred, cache = rnn_cell_forward(xt, a_prev, parameters)
print("a_next[4] = ", a_next[4])
print("a_next.shape = ", a_next.shape)
print("yt_pred[1] =", yt_pred[1])
print("yt_pred.shape = ", yt_pred.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试结果如下：

a_next[4] =  [ 0.59584544  0.18141802  0.61311866  0.99808218  0.85016201  0.99980978
 -0.18887155  0.99815551  0.6531151   0.82872037]
a_next.shape =  (5, 10)
yt_pred[1] = [0.9888161  0.01682021 0.21140899 0.36817467 0.98988387 0.88945212
 0.36920224 0.9966312  0.9982559  0.17746526]
yt_pred.shape =  (2, 10)
1
2
3
4
5
6

（2）RNN 的前向传播

可以看到 RNN 实际就是刚刚构建的单元格的重复连接，如果输入的数据序列经过 10 个时间步，那么将复制 RNN 单元10 次，每个单元将前一个单元中的隐藏状态（$a^{<t-1>}$）和当前时间步的输入数据（$x^{<t>}$）作为输入。它为此时间步输出隐藏状态（$a^{<t>}$）和预测（$y^{<t>}$）。

我们要根据上图来实现前向传播的代码，需要实现以下几步：

1. 创建 0向量 zeros(a)，它将保存 RNN 计算的所有隐藏状态
2. 使用 “$a_0$” 来初始化 ”next“ 的隐藏状态
3. 循环所有时间步
   • 使用 rnn_cell_forward 函数来更新 ”next“ 隐藏状态与 cache
   • 使用 $a$ 来保存 ”next“ 隐藏状态（第$t$）个位置
   • 使用 $y$ 来保存预测值
   • 把 cache 保存到 “caches” 列表中
4. 返回 $a,y$ 与 caches

# 前向传播
def rnn_forward(x, a0, parameters):
    """
    根据上图来实现循环神经网络的前向传播
    
    参数：
        x -- 输入的全部数据，维度为(n_x, m, T_x)
        a0 -- 初始化隐藏状态，维度为 (n_a, m)
        parameters -- 字典，包含了以下内容:
                        Wax -- 矩阵，输入乘以权重，维度为（n_a, n_x）
                        Waa -- 矩阵，隐藏状态乘以权重，维度为（n_a, n_a）
                        Wya -- 矩阵，隐藏状态与输出相关的权重矩阵，维度为（n_y, n_a）
                        ba  -- 偏置，维度为（n_a, 1）
                        by  -- 偏置，隐藏状态与输出相关的偏置，维度为（n_y, 1）
    
    返回：
        a -- 所有时间步的隐藏状态，维度为(n_a, m, T_x)
        y_pred -- 所有时间步的预测，维度为(n_y, m, T_x)
        caches -- 为反向传播的保存的元组，维度为（【列表类型】cache, x)）
    """
    # 初始化 caches，它将以列表类型包含所有的 cache
    caches = []
    
    # 获取 x 与 Wya 的维度信息
    n_x, m, T_x = x.shape
    n_y, n_a = parameters["Wya"].shape
    
    # 使用 0 来初始化 a 和 y
    a = np.zeros([n_a, m, T_x])
    y_pred = np.zeros([n_y, m, T_x])
    
    # 初始化 next
    a_next = a0
    
    # 遍历所有时间步
    for t in range(T_x):
        ## 1.使用 rnn_cell_forward 来更新 next 隐藏状态与 cache
        a_next, yt_pred, cache = rnn_cell_forward(x[:, :, t], a_next, parameters)
        
        ## 2.使用 a 来保存 next 隐藏状态
        a[:, :, t] = a_next
        
        ## 3.使用 y 来保存预测值
        y_pred[:, :, t] = yt_pred
        
        ## 4.把 cache 保存到 caches 列表中
        caches.append(cache)
        
    # 保存反向传播所需要的参数
    caches = (caches, x)
    
    return a, y_pred, caches
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

测试：

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

测试结果如下：

a[4][1] =  [-0.99999375  0.77911235 -0.99861469 -0.99833267]
a.shape =  (5, 10, 4)
y_pred[1][3] = [0.79560373 0.86224861 0.11118257 0.81515947]
y_pred.shape =  (2, 10, 4)
caches[1][1][3] = [-1.1425182  -0.34934272 -0.20889423  0.58662319]
len(caches) =  2
1
2
3
4
5
6

我们构建了循环神经网络的前向传播函数，这对于某些应用程序来说已经足够好了，但是它还存在梯度消失的问题。当每个输出 $y^{<t>}$ 是根据局部的上下文来进行预测的时候，它的效果是比较好的（意思是输入的是 $x^{⟨t\prime ⟩}$ ，其中 $t^{\prime }$ 与 $t$ 相隔不是太远。

接下来我们要构建一个更复杂的 LSTM 模型，它可以更好地解决梯度消失的问题，LSTM 能够更好地记住一条信息，并且可以在很多时间步中保存。

2. 长短时记忆（Long Short-Term Memory (LSTM)）网络

下图是 LSTM 模块：

与上面的 RNN 例子相类似，我们先来实现一个 LSTM 单元，只执行一个时间步，然后在循环中调用，以处理所有输入数据。

（1）“门” 的介绍

1. 遗忘门
假设我们正在阅读文本中的单词，并希望使用 LSTM 来跟踪语法结构，比如主语是单数还是复数。如果主语从单数变为复数，我们需要找到一种方法来摆脱我们先前存储的单复数状态的记忆值。在 LSTM 中，遗忘门是这样做的：$${\Gamma }_f^{<t>}=\sigma (W_f[a^{<t-1>},{\text{x}}^{<t>}]+b_f)$$其中，$W_f$ 是控制遗忘门的权值，我们把 $a^{<t-1>},{\text{x}}^{<t>}$ 连接起来变为 $[a^{<t-1>},{\text{x}}^{<t>}]$，然后乘以权值 $W_f$，再加上偏置 $b_f$，最后经过激活函数得到一个向量 ${\Gamma }_f^{<t>}$，其值在 0 与 1 之间。这个遗忘门向量将于前一个单元状态 $c^{<t-1>}$ 相乘，因此，如果 ${\Gamma }_f^{<t>}$ 向量中的一个值是 0（或者 $\approx$ 0），则意味着 LSTM 应该删除对应的信息，如果其中有为 1 的值，那么 LSTM 将会保留该信息。
2. 更新门
一旦我们“忘记”所讨论的过去的主语是单数，那么我们需要找到一种方法来更新它，以反映新的主语现在是复数。这里是更新门的公式：$${\Gamma }_u^{<t>}=\sigma (W_u[a^{<t-1>},{\text{x}}^{<t>}]+b_u)$$与遗忘门相似，${\Gamma }_u^{<t>}$ 向量的值在 0 与 1 之间，为了计算 $c^{<t>}$ ，它会与 ${\tilde{c}}^{<t>}$ 相乘。
3. 更新单元
为了更新主题，我们需要创建一个新的向量，我们可以将其添加到之前的单元状态中，我们使用的公式是：$${\tilde{c}}^{<t>}=\text{tanh}(W_c[a^{<t-1>},{\text{x}}^{<t>}]+b_c)$$最后，单元的新状态为：$$c^{<t>}={\Gamma }_f^{<t>}\cdot c^{<t-1>}+{\Gamma }_u^{<t>}\cdot {\tilde{c}}^{<t>}$$
4. 输出门
为了决定我们将使用哪种输出，我们将使用以下两个公式：$${\Gamma }_o^{<t>}=\sigma (W_o[a^{<t-1>},{\text{x}}^{<t>}]+b_o)$$$$={\Gamma }_o^{<t>}\cdot \text{tanh}(c^{<t>})$$

（2）LSTM 单元

我们根据上述公式来实现一个 LSTM 单元，步骤如下：

1. 把 $a^{<t-1>},{\text{x}}^{<t>}$ 连接起来变为一个矩阵： contact = [ a < t − 1 > x < t > ] \text{contact}=\left[
   a<t−1>x<t>" role="presentation" style="position: relative;">a<t−1>x<t>$$\begin{array}{c}{a}^{<t-1>}\\ {\text{x}}^{<t>}\end{array}$$
   \right] contact=[a<t−1>x<t>​]
2. 计算上述公式，其中 sigmoid() 与 tanh() 在 rnn_utils 中
3. 计算预测值 $y^{<t>}$，softmax() 在 rnn_utils 中$${\text{y}}^{<t>}=\text{softmax}(W_y{a}^{<t>}+b_y)$$

def lstm_cell_forward(xt, a_prev, c_prev, parameters):
    """
    根据上述实现一个LSTM单元的前向传播。
    
    参数：
        xt -- 在时间步“t”输入的数据，维度为(n_x, m)
        a_prev -- 上一个时间步“t-1”的隐藏状态，维度为(n_a, m)
        c_prev -- 上一个时间步“t-1”的记忆状态，维度为(n_a, m)
        parameters -- 字典类型的变量，包含了：
                        Wf -- 遗忘门的权值，维度为(n_a, n_a + n_x)
                        bf -- 遗忘门的偏置，维度为(n_a, 1)
                        Wi -- 更新门的权值，维度为(n_a, n_a + n_x)
                        bi -- 更新门的偏置，维度为(n_a, 1)
                        Wc -- 第一个“tanh”的权值，维度为(n_a, n_a + n_x)
                        bc -- 第一个“tanh”的偏置，维度为(n_a, n_a + n_x)
                        Wo -- 输出门的权值，维度为(n_a, n_a + n_x)
                        bo -- 输出门的偏置，维度为(n_a, 1)
                        Wy -- 隐藏状态与输出相关的权值，维度为(n_y, n_a)
                        by -- 隐藏状态与输出相关的偏置，维度为(n_y, 1)
    返回：
        a_next -- 下一个隐藏状态，维度为(n_a, m)
        c_next -- 下一个记忆状态，维度为(n_a, m)
        yt_pred -- 在时间步“t”的预测，维度为(n_y, m)
        cache -- 包含了反向传播所需要的参数，包含了(a_next, c_next, a_prev, c_prev, xt, parameters)
        
    注意：
        ft/it/ot表示遗忘/更新/输出门，cct表示候选值(c tilda)，c表示记忆值。
    """
    # 从 parameters 中获取相关值
    Wf = parameters["Wf"]
    bf = parameters["bf"]
    Wi = parameters["Wi"]
    bi = parameters["bi"]
    Wc = parameters["Wc"]
    bc = parameters["bc"]
    Wo = parameters["Wo"]
    bo = parameters["bo"]
    Wy = parameters["Wy"]
    by = parameters["by"]
    
    # 获取 xt 与 Wy 的维度信息
    n_x, m = xt.shape
    n_y, n_a = Wy.shape
    
    # 1.连接 a_prev 与 xt
    contact = np.zeros([n_a + n_x, m])
    contact[:n_a, :] = a_prev
    contact[n_a:, :] = xt
    
    # 2.根据公式计算 ft、it、cct、c_next、ot、a_next
    ## 遗忘门
    ft = rnn_utils.sigmoid(np.dot(Wf, contact) + bf)
    
    ## 更新门
    it = rnn_utils.sigmoid(np.dot(Wi, contact) + bi)
    
    ## 更新单元
    cct = np.tanh(np.dot(Wc, contact) + bc)
    
    ## 更新单元
    c_next = ft * c_prev + it * cct
    
    ## 输出门
    ot = rnn_utils.sigmoid(np.dot(Wo, contact) + bo)
    
    ## 输出门
    a_next = ot * np.tanh(c_next)
    
    # 3.计算 LSTM 单元的预测值
    yt_pred = rnn_utils.softmax(np.dot(Wy, a_next) + by)
    
    # 保存包含反向传播所需要的参数
    cache = (a_next, c_next, a_prev, c_prev, ft, it, cct, ot, xt, parameters)
    
    return a_next, c_next, yt_pred, cache
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

测试：

np.random.seed(1)
xt = np.random.randn(3,10)
a_prev = np.random.randn(5,10)
c_prev = np.random.randn(5,10)
Wf = np.random.randn(5, 5+3)
bf = np.random.randn(5,1)
Wi = np.random.randn(5, 5+3)
bi = np.random.randn(5,1)
Wo = np.random.randn(5, 5+3)
bo = np.random.randn(5,1)
Wc = np.random.randn(5, 5+3)
bc = np.random.randn(5,1)
Wy = np.random.randn(2,5)
by = np.random.randn(2,1)

parameters = {"Wf": Wf, "Wi": Wi, "Wo": Wo, "Wc": Wc, "Wy": Wy, "bf": bf, "bi": bi, "bo": bo, "bc": bc, "by": by}

a_next, c_next, yt, cache = lstm_cell_forward(xt, a_prev, c_prev, parameters)
print("a_next[4] = ", a_next[4])
print("a_next.shape = ", c_next.shape)
print("c_next[2] = ", c_next[2])
print("c_next.shape = ", c_next.shape)
print("yt[1] =", yt[1])
print("yt.shape = ", yt.shape)
print("cache[1][3] =", cache[1][3])
print("len(cache) = ", len(cache))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

测试结果如下：

a_next[4] =  [-0.66408471  0.0036921   0.02088357  0.22834167 -0.85575339  0.00138482
  0.76566531  0.34631421 -0.00215674  0.43827275]
a_next.shape =  (5, 10)
c_next[2] =  [ 0.63267805  1.00570849  0.35504474  0.20690913 -1.64566718  0.11832942
  0.76449811 -0.0981561  -0.74348425 -0.26810932]
c_next.shape =  (5, 10)
yt[1] = [0.79913913 0.15986619 0.22412122 0.15606108 0.97057211 0.31146381
 0.00943007 0.12666353 0.39380172 0.07828381]
yt.shape =  (2, 10)
cache[1][3] = [-0.16263996  1.03729328  0.72938082 -0.54101719  0.02752074 -0.30821874
  0.07651101 -1.03752894  1.41219977 -0.37647422]
len(cache) =  10
1
2
3
4
5
6
7
8
9
10
11
12

（3）LSTM 的前向传播

我们已经实现了 LSTM 单元的一个时间步的前向传播，现在我们要对 LSTM 网络进行前向传播计算：

和 RNN 类似，我们只需将 lstm_cell_forward() 运行 $T_{\text{x}}$ 个时间步即可。注意：$c^{<0>}$ 用 0 来初始化。

def lstm_forward(x, a0, parameters):
    """
    根据上述公式来实现LSTM单元组成的的循环神经网络
    
    参数：
        x -- 所有时间步的输入数据，维度为(n_x, m, T_x)
        a0 -- 初始化隐藏状态，维度为(n_a, m)
        parameters -- python字典，包含了以下参数：
                        Wf -- 遗忘门的权值，维度为(n_a, n_a + n_x)
                        bf -- 遗忘门的偏置，维度为(n_a, 1)
                        Wi -- 更新门的权值，维度为(n_a, n_a + n_x)
                        bi -- 更新门的偏置，维度为(n_a, 1)
                        Wc -- 第一个“tanh”的权值，维度为(n_a, n_a + n_x)
                        bc -- 第一个“tanh”的偏置，维度为(n_a, n_a + n_x)
                        Wo -- 输出门的权值，维度为(n_a, n_a + n_x)
                        bo -- 输出门的偏置，维度为(n_a, 1)
                        Wy -- 隐藏状态与输出相关的权值，维度为(n_y, n_a)
                        by -- 隐藏状态与输出相关的偏置，维度为(n_y, 1)
        
    返回：
        a -- 所有时间步的隐藏状态，维度为(n_a, m, T_x)
        y -- 所有时间步的预测值，维度为(n_y, m, T_x)
        caches -- 为反向传播的保存的元组，维度为（【列表类型】cache, x)）
    """
    # 初始化 caches
    caches = []
    
    # 获取 xt 与 Wy 的维度信息
    n_x, m, T_x = x.shape
    n_y, n_a = parameters["Wy"].shape
    
    # 使用 0 来初始化"a","c","y"
    a = np.zeros([n_a, m, T_x])
    c = np.zeros([n_a, m, T_x])
    y = np.zeros([n_y, m, T_x])
    
    # 初始化 a_next, c_next
    a_next = a0
    c_next = np.zeros([n_a, m])
    
    # 遍历所有的时间步
    for t in range(T_x):
        # 更新下一个隐藏状态，下一个记忆状态，计算预测值，获取 cache
        a_next, c_next, yt_pred, cache = lstm_cell_forward(x[:, :, t], a_next, c_next, parameters)
        
        # 保存新的下一个隐藏状态到变量 a 中
        a[:, :, t] = a_next
        
        # 保存预测值到变量 y 中
        y[:, :, t] = yt_pred
        
        # 保存下一个单元状态到变量 c 中
        c[:, :, t] = c_next
        
        # 把 cache 添加到 caches 中
        caches.append(cache)
        
    # 保存反向传播需要的参数
    caches = (caches, x)
    
    return a, y, c, caches
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

测试：

np.random.seed(1)
x = np.random.randn(3,10,7)
a0 = np.random.randn(5,10)
Wf = np.random.randn(5, 5+3)
bf = np.random.randn(5,1)
Wi = np.random.randn(5, 5+3)
bi = np.random.randn(5,1)
Wo = np.random.randn(5, 5+3)
bo = np.random.randn(5,1)
Wc = np.random.randn(5, 5+3)
bc = np.random.randn(5,1)
Wy = np.random.randn(2,5)
by = np.random.randn(2,1)

parameters = {"Wf": Wf, "Wi": Wi, "Wo": Wo, "Wc": Wc, "Wy": Wy, "bf": bf, "bi": bi, "bo": bo, "bc": bc, "by": by}

a, y, c, caches = lstm_forward(x, a0, parameters)
print("a[4][3][6] = ", a[4][3][6])
print("a.shape = ", a.shape)
print("y[1][4][3] =", y[1][4][3])
print("y.shape = ", y.shape)
print("caches[1][1[1]] =", caches[1][1][1])
print("c[1][2][1]", c[1][2][1])
print("len(caches) = ", len(caches))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

测试结果如下：

a[4][3][6] =  0.17211776753291672
a.shape =  (5, 10, 7)
y[1][4][3] = 0.9508734618501101
y.shape =  (2, 10, 7)
caches[1][1[1]] = [ 0.82797464  0.23009474  0.76201118 -0.22232814 -0.20075807  0.18656139
  0.41005165]
c[1][2][1] -0.8555449167181981
len(caches) =  2
1
2
3
4
5
6
7
8

3. RNN 的反向传播

在现代深度学习框架中，我们只需要实现前向传播，框架负责反向传播，因此大多数深度学习工程师不需要为反向传播的细节而烦恼。 但是，如果您是微积分方面的专家并希望在RNN中查看反向传播的详细信息，则可以学习这个选学部分。

在前面课程中，我们实现了一个简单（完全连接）的神经网络，我们使用反向传播来计算与更新参数的成本相关的导数。类似地，在循环神经网络中，我们可以计算与成本相关的导数，以便更新参数。反向传播的方程非常复杂，我们没有在视频中推导它们，但是，我们将在下面简要介绍它们。

（1）RNN 的反向传播

我们将开始计算基本的 RNN 单元的反向传播，我们先来看一下下面的图：

为了计算 rnn_cell_backward()，我们需要计算下面的公式：$\text{tanh(x)}$ 的导数是 $1-(\text{tanh(x)}{)}^2$。类似的，对于 $(\frac{\partial J}{\partial W_{\text{ax}}},\frac{\partial J}{\partial W_{\text{aa}}},\frac{\partial J}{\partial \text{b}})$ 而言，$\text{tanh(u)}$ 的导数是 $1-(\text{tanh(x)}{)}^2\text{du}$。

def rnn_cell_backward(da_next, cache):
    """
    实现基本的RNN单元的单步反向传播
    
    参数：
        da_next -- 关于下一个隐藏状态的损失的梯度。
        cache -- 字典类型，rnn_step_forward()的输出
        
    返回：
        gradients -- 字典，包含了以下参数：
                        dx -- 输入数据的梯度，维度为(n_x, m)
                        da_prev -- 上一隐藏层的隐藏状态，维度为(n_a, m)
                        dWax -- 输入到隐藏状态的权重的梯度，维度为(n_a, n_x)
                        dWaa -- 隐藏状态到隐藏状态的权重的梯度，维度为(n_a, n_a)
                        dba -- 偏置向量的梯度，维度为(n_a, 1)
    """
    # 获取 cache 的值
    a_next, a_prev, xt, parameters = cache
    
    # 从 parameters 中获取参数
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]
    
    # 计算 tanh 相对于 a_next 的梯度
    dtanh = (1 - np.square(a_next)) * da_next
    
    # 计算关于 Wax 损失的梯度
    dxt = np.dot(Wax.T, dtanh)
    dWax = np.dot(dtanh, xt.T)
    
    # 计算关于 Waa 损失的梯度
    da_prev = np.dot(Waa.T, dtanh)
    dWaa = np.dot(dtanh, a_prev.T)
    
    # 计算关于 b 损失的梯度
    dba = np.sum(dtanh, keepdims=True, axis=-1)
    
    # 保存这些梯度到字典内
    gradients = {"dxt": dxt, "da_prev": da_prev, "dWax": dWax,
                 "dWaa": dWaa, "dba": dba}
    
    return gradients
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

测试：

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)
b = 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

测试结果如下：

gradients["dxt"][1][2] = -0.4605641030588796
gradients["dxt"].shape = (3, 10)
gradients["da_prev"][2][3] = 0.08429686538067671
gradients["da_prev"].shape = (5, 10)
gradients["dWax"][3][1] = 0.3930818739219304
gradients["dWax"].shape = (5, 3)
gradients["dWaa"][1][2] = -0.2848395578696066
gradients["dWaa"].shape = (5, 5)
gradients["dba"][4] = [0.80517166]
gradients["dba"].shape = (5, 1)
1
2
3
4
5
6
7
8
9
10

单步反向传播已经实现了，我们接下来实现整个 RNN 的反向传播：

def rnn_backward(da, caches):
    """
    在整个输入数据序列上实现RNN的反向传播
    
    参数：
        da -- 所有隐藏状态的梯度，维度为(n_a, m, T_x)
        caches -- 包含向前传播的信息的元组
    
    返回：    
        gradients -- 包含了梯度的字典：
                        dx -- 关于输入数据的梯度，维度为(n_x, m, T_x)
                        da0 -- 关于初始化隐藏状态的梯度，维度为(n_a, m)
                        dWax -- 关于输入权重的梯度，维度为(n_a, n_x)
                        dWaa -- 关于隐藏状态的权值的梯度，维度为(n_a, n_a)
                        dba -- 关于偏置的梯度，维度为(n_a, 1)
    """
    # 从 caches 中获取第一个 cache（t=1）的值
    caches, x = caches
    a1, a0, x1, parameters = caches[0]
    
    # 获取 da 与 x1 的维度信息
    n_a, m, T_x = da.shape
    n_x, m = x1.shape
    
    # 初始化梯度
    dx = np.zeros([n_x, m, T_x])
    dWax = np.zeros([n_a, n_x])
    dWaa = np.zeros([n_a, n_a])
    dba = np.zeros([n_a, 1])
    da0 = np.zeros([n_a, m])
    da_prevt = np.zeros([n_a, m])
    
    # 处理所有时间步
    for t in reversed(range(T_x)):
        # 计算时间步 t 时的梯度
        gradients = rnn_cell_backward(da[:, :, t] + da_prevt, caches[t])
        
        # 从梯度中获取导数
        dxt, da_prevt, dWaxt, dWaat, dbat = gradients["dxt"], gradients["da_prev"], gradients["dWax"], gradients["dWaa"], gradients["dba"]
        
        # 通过在时间步 t 添加它们的导数来增加关于全局导数的参数
        dx[:, :, t] = dxt
        dWax += dWaxt
        dWaa += dWaat
        dba += dbat
        
    # 将 da0 设置为 a 的梯度，该梯度已通过所有时间步骤进行反向传播
    da0 = da_prevt
    
    # 保存这些梯度到字典内
    gradients = {"dx": dx, "da0": da0, "dWax": dWax, "dWaa": dWaa,"dba": dba}
    
    return gradients
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

测试：

np.random.seed(1)
x = np.random.randn(3,10,4)
a0 = 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, y, caches = rnn_forward(x, a0, parameters)
da = np.random.randn(5, 10, 4)
gradients = rnn_backward(da, caches)

print("gradients[\"dx\"][1][2] =", gradients["dx"][1][2])
print("gradients[\"dx\"].shape =", gradients["dx"].shape)
print("gradients[\"da0\"][2][3] =", gradients["da0"][2][3])
print("gradients[\"da0\"].shape =", gradients["da0"].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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

测试结果如下：

gradients["dx"][1][2] = [-2.07101689 -0.59255627  0.02466855  0.01483317]
gradients["dx"].shape = (3, 10, 4)
gradients["da0"][2][3] = -0.3149423751266499
gradients["da0"].shape = (5, 10)
gradients["dWax"][3][1] = 11.264104496527777
gradients["dWax"].shape = (5, 3)
gradients["dWaa"][1][2] = 2.3033331265798926
gradients["dWaa"].shape = (5, 5)
gradients["dba"][4] = [-0.74747722]
gradients["dba"].shape = (5, 1)
1
2
3
4
5
6
7
8
9
10

（2）LSTM 反向传播

LSTM 反向传播比前向传播更复杂一些。我们已经提供了下面 LSTM 反向传播的所有方程。
1. 门的导数

2. 参数的导数

为了计算 ${\text{db}}_{\text{f}},{\text{db}}_{\text{u}},{\text{db}}_{\text{c}},{\text{db}}_{\text{o}}$ 我们需要在 $\text{d}{\Gamma }_{\text{f}}^{<t>},\text{d}{\Gamma }_{\text{u}}^{<t>},\text{d}{\tilde{c}}^{<t>},\text{d}{\Gamma }_{\text{o}}^{<t>}$ 上使用（axis=1）来进行求和，需要注意的事情是要使用 keep_dims = True。我们将计算关于先前隐藏状态、先前记忆状态和输入的导数。$${\text{da}}_{\text{prev}}=W_{\text{f}}^T\cdot \text{d}{\Gamma }_{\text{f}}^{<t>}+W_{\text{u}}^T\cdot \text{d}{\Gamma }_{\text{u}}^{<t>}+W_{\text{c}}^T\cdot \text{d}{\tilde{c}}^{<t>}+W_{\text{o}}^T\cdot \text{d}{\Gamma }_{\text{o}}^{<t>}$$ $${\text{dc}}_{\text{prev}}={\text{dc}}_{\text{next}}^T\cdot {\Gamma }_{\text{f}}^{<t>}+{\Gamma }_{\text{o}}^{<t>}\cdot (1-(\text{tanh}(c_{\text{next}}){)}^2)\cdot {\Gamma }_{\text{f}}^{<t>}\cdot {\text{da}}_{\text{next}}$$ $${\text{dx}}^{<t>}=W_{\text{f}}^T\cdot \text{d}{\Gamma }_{\text{f}}^{<t>}+W_{\text{u}}^T\cdot \text{d}{\Gamma }_{\text{u}}^{<t>}+W_{\text{c}}^T\cdot \text{d}{\tilde{c}}^{<t>}+W_{\text{o}}^T\cdot \text{d}{\Gamma }_{\text{o}}^{<t>}$$

def lstm_cell_backward(da_next, dc_next, cache):
    """
    实现LSTM的单步反向传播
    
    参数：
        da_next -- 下一个隐藏状态的梯度，维度为(n_a, m)
        dc_next -- 下一个单元状态的梯度，维度为(n_a, m)
        cache -- 来自前向传播的一些参数
        
    返回：
        gradients -- 包含了梯度信息的字典：
                        dxt -- 输入数据的梯度，维度为(n_x, m)
                        da_prev -- 先前的隐藏状态的梯度，维度为(n_a, m)
                        dc_prev -- 前的记忆状态的梯度，维度为(n_a, m, T_x)
                        dWf -- 遗忘门的权值的梯度，维度为(n_a, n_a + n_x)
                        dbf -- 遗忘门的偏置的梯度，维度为(n_a, 1)
                        dWi -- 更新门的权值的梯度，维度为(n_a, n_a + n_x)
                        dbi -- 更新门的偏置的梯度，维度为(n_a, 1)
                        dWc -- 第一个“tanh”的权值的梯度，维度为(n_a, n_a + n_x)
                        dbc -- 第一个“tanh”的偏置的梯度，维度为(n_a, n_a + n_x)
                        dWo -- 输出门的权值的梯度，维度为(n_a, n_a + n_x)
                        dbo -- 输出门的偏置的梯度，维度为(n_a, 1)
    """
    # 从 cache 中获取信息
    (a_next, c_next, a_prev, c_prev, ft, it, cct, ot, xt, parameters) = cache
    
    # 获取 xt 与 a_next 的维度信息
    n_x, m = xt.shape
    n_a, m = a_next.shape
    
    # 根据上述公式来计算门的导数
    dot = da_next * np.tanh(c_next) * ot * (1 - ot)
    dcct = (dc_next * it + ot * (1 - np.square(np.tanh(c_next))) * it * da_next) * (1 - np.square(cct))
    dit = (dc_next * cct + ot * (1 - np.square(np.tanh(c_next))) * cct * da_next) * it * (1 - it)
    dft = (dc_next * c_prev + ot * (1 - np.square(np.tanh(c_next))) * c_prev * da_next) * ft * (1 - ft)
    
    # 根据上述公式来计算参数的导数
    concat = np.concatenate((a_prev, xt), axis=0).T
    dWf = np.dot(dft, concat)
    dWi = np.dot(dit, concat)
    dWc = np.dot(dcct, concat)
    dWo = np.dot(dot, concat)
    dbf = np.sum(dft,axis=1,keepdims=True)
    dbi = np.sum(dit,axis=1,keepdims=True)
    dbc = np.sum(dcct,axis=1,keepdims=True)
    dbo = np.sum(dot,axis=1,keepdims=True)
    
    # 使用上述公式来计算先前隐藏状态、先前记忆状态、输入的导数
    da_prev = np.dot(parameters["Wf"][:, :n_a].T, dft) + np.dot(parameters["Wc"][:, :n_a].T, dcct) + np.dot(parameters["Wi"][:, :n_a].T, dit) + np.dot(parameters["Wo"][:, :n_a].T, dot)
        
    dc_prev = dc_next * ft + ot * (1 - np.square(np.tanh(c_next))) * ft * da_next
    
    dxt = np.dot(parameters["Wf"][:, n_a].T, dft) + np.dot(parameters["Wc"][:, n_a].T, dcct) + np.dot(parameters["Wi"][:, n_a:].T, dit) + np.dot(parameters["Wo"][:, n_a:].T, dot)
        
    # 保存梯度信息到字典
    gradients = {"dxt": dxt, "da_prev": da_prev, "dc_prev": dc_prev, "dWf": dWf,"dbf": dbf, "dWi": dWi,"dbi": dbi,
                "dWc": dWc,"dbc": dbc, "dWo": dWo,"dbo": dbo}
    
    return gradients
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

测试：

np.random.seed(1)
xt = np.random.randn(3,10)
a_prev = np.random.randn(5,10)
c_prev = np.random.randn(5,10)
Wf = np.random.randn(5, 5+3)
bf = np.random.randn(5,1)
Wi = np.random.randn(5, 5+3)
bi = np.random.randn(5,1)
Wo = np.random.randn(5, 5+3)
bo = np.random.randn(5,1)
Wc = np.random.randn(5, 5+3)
bc = np.random.randn(5,1)
Wy = np.random.randn(2,5)
by = np.random.randn(2,1)

parameters = {"Wf": Wf, "Wi": Wi, "Wo": Wo, "Wc": Wc, "Wy": Wy, "bf": bf, "bi": bi, "bo": bo, "bc": bc, "by": by}

a_next, c_next, yt, cache = lstm_cell_forward(xt, a_prev, c_prev, parameters)

da_next = np.random.randn(5,10)
dc_next = np.random.randn(5,10)
gradients = lstm_cell_backward(da_next, dc_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[\"dc_prev\"][2][3] =", gradients["dc_prev"][2][3])
print("gradients[\"dc_prev\"].shape =", gradients["dc_prev"].shape)
print("gradients[\"dWf\"][3][1] =", gradients["dWf"][3][1])
print("gradients[\"dWf\"].shape =", gradients["dWf"].shape)
print("gradients[\"dWi\"][1][2] =", gradients["dWi"][1][2])
print("gradients[\"dWi\"].shape =", gradients["dWi"].shape)
print("gradients[\"dWc\"][3][1] =", gradients["dWc"][3][1])
print("gradients[\"dWc\"].shape =", gradients["dWc"].shape)
print("gradients[\"dWo\"][1][2] =", gradients["dWo"][1][2])
print("gradients[\"dWo\"].shape =", gradients["dWo"].shape)
print("gradients[\"dbf\"][4] =", gradients["dbf"][4])
print("gradients[\"dbf\"].shape =", gradients["dbf"].shape)
print("gradients[\"dbi\"][4] =", gradients["dbi"][4])
print("gradients[\"dbi\"].shape =", gradients["dbi"].shape)
print("gradients[\"dbc\"][4] =", gradients["dbc"][4])
print("gradients[\"dbc\"].shape =", gradients["dbc"].shape)
print("gradients[\"dbo\"][4] =", gradients["dbo"][4])
print("gradients[\"dbo\"].shape =", gradients["dbo"].shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

测试结果如下：

gradients["dxt"][1][2] = 1.6671905750683789
gradients["dxt"].shape = (3, 10)
gradients["da_prev"][2][3] = -0.06396214197109239
gradients["da_prev"].shape = (5, 10)
gradients["dc_prev"][2][3] = 0.7975220387970015
gradients["dc_prev"].shape = (5, 10)
gradients["dWf"][3][1] = -0.14795483816449725
gradients["dWf"].shape = (5, 8)
gradients["dWi"][1][2] = 1.0574980552259903
gradients["dWi"].shape = (5, 8)
gradients["dWc"][3][1] = 2.3045621636876668
gradients["dWc"].shape = (5, 8)
gradients["dWo"][1][2] = 0.3313115952892108
gradients["dWo"].shape = (5, 8)
gradients["dbf"][4] = [0.18864637]
gradients["dbf"].shape = (5, 1)
gradients["dbi"][4] = [-0.40142491]
gradients["dbi"].shape = (5, 1)
gradients["dbc"][4] = [0.25587763]
gradients["dbc"].shape = (5, 1)
gradients["dbo"][4] = [0.13893342]
gradients["dbo"].shape = (5, 1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（3）LSTM 网络的反向传播

这部分与我们在上面实现的 rnn_backward 函数非常相似。我们将首先创建与返回变量相同维度的变量。然后将遍历从结束到开始的所有时间步，并调用在每次迭代时为 LSTM 实现的单步反向传播功能。然后我们将通过单独求和来更新参数，最后返回一个带有新梯度的字典。

def lstm_backward(da, caches):
    """
    实现LSTM网络的反向传播
    
    参数：
        da -- 关于隐藏状态的梯度，维度为(n_a, m, T_x)
        cachses -- 前向传播保存的信息
    
    返回：
        gradients -- 包含了梯度信息的字典：
                        dx -- 输入数据的梯度，维度为(n_x, m，T_x)
                        da0 -- 先前的隐藏状态的梯度，维度为(n_a, m)
                        dWf -- 遗忘门的权值的梯度，维度为(n_a, n_a + n_x)
                        dbf -- 遗忘门的偏置的梯度，维度为(n_a, 1)
                        dWi -- 更新门的权值的梯度，维度为(n_a, n_a + n_x)
                        dbi -- 更新门的偏置的梯度，维度为(n_a, 1)
                        dWc -- 第一个“tanh”的权值的梯度，维度为(n_a, n_a + n_x)
                        dbc -- 第一个“tanh”的偏置的梯度，维度为(n_a, n_a + n_x)
                        dWo -- 输出门的权值的梯度，维度为(n_a, n_a + n_x)
                        dbo -- 输出门的偏置的梯度，维度为(n_a, 1)
        
    """
    # 从 caches 中获取第一个 cache(t=1) 的值
    caches, x = caches
    (a1, c1, a0, c0, f1, i1, cc1, o1, x1, parameters) = caches[0]
    
    # 获取 da 与 x1 的维度信息
    n_a, m, T_x = da.shape
    n_x, m = x1.shape
    
    # 初始化梯度
    dx = np.zeros([n_x, m, T_x])
    da0 = np.zeros([n_a, m])
    da_prevt = np.zeros([n_a, m])
    dc_prevt = np.zeros([n_a, m])
    dWf = np.zeros([n_a, n_a + n_x])
    dWi = np.zeros([n_a, n_a + n_x])
    dWc = np.zeros([n_a, n_a + n_x])
    dWo = np.zeros([n_a, n_a + n_x])
    dbf = np.zeros([n_a, 1])
    dbi = np.zeros([n_a, 1])
    dbc = np.zeros([n_a, 1])
    dbo = np.zeros([n_a, 1])
    
    # 处理所有时间步
    for t in reversed(range(T_x)):
        # 使用 Lstm_cell_backward 函数来计算所有梯度
        gradients = lstm_cell_backward(da[:, :, t], dc_prevt, caches[t])
        # 保存相关参数
        dx[:, :, t] = gradients['dxt']
        dWf = dWf + gradients['dWf']
        dWi = dWi+gradients['dWi']
        dWc = dWc+gradients['dWc']
        dWo = dWo+gradients['dWo']
        dbf = dbf+gradients['dbf']
        dbi = dbi+gradients['dbi']
        dbc = dbc+gradients['dbc']
        dbo = dbo+gradients['dbo']
        
    # 将第一个激活的梯度设置为反向传播的梯度 da_prev
    da0 = gradients['da_prev']
    
    # 保存所有梯度到字典变量内
    gradients = {"dx": dx, "da0": da0, "dWf": dWf,"dbf": dbf, "dWi": dWi,"dbi": dbi,
                "dWc": dWc,"dbc": dbc, "dWo": dWo,"dbo": dbo}
    
    return gradients
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

测试：

np.random.seed(1)
x = np.random.randn(3,10,7)
a0 = np.random.randn(5,10)
Wf = np.random.randn(5, 5+3)
bf = np.random.randn(5,1)
Wi = np.random.randn(5, 5+3)
bi = np.random.randn(5,1)
Wo = np.random.randn(5, 5+3)
bo = np.random.randn(5,1)
Wc = np.random.randn(5, 5+3)
bc = np.random.randn(5,1)

parameters = {"Wf": Wf, "Wi": Wi, "Wo": Wo, "Wc": Wc, "Wy": Wy, "bf": bf, "bi": bi, "bo": bo, "bc": bc, "by": by}

a, y, c, caches = lstm_forward(x, a0, parameters)

da = np.random.randn(5, 10, 4)
gradients = lstm_backward(da, caches)

print("gradients[\"dx\"][1][2] =", gradients["dx"][1][2])
print("gradients[\"dx\"].shape =", gradients["dx"].shape)
print("gradients[\"da0\"][2][3] =", gradients["da0"][2][3])
print("gradients[\"da0\"].shape =", gradients["da0"].shape)
print("gradients[\"dWf\"][3][1] =", gradients["dWf"][3][1])
print("gradients[\"dWf\"].shape =", gradients["dWf"].shape)
print("gradients[\"dWi\"][1][2] =", gradients["dWi"][1][2])
print("gradients[\"dWi\"].shape =", gradients["dWi"].shape)
print("gradients[\"dWc\"][3][1] =", gradients["dWc"][3][1])
print("gradients[\"dWc\"].shape =", gradients["dWc"].shape)
print("gradients[\"dWo\"][1][2] =", gradients["dWo"][1][2])
print("gradients[\"dWo\"].shape =", gradients["dWo"].shape)
print("gradients[\"dbf\"][4] =", gradients["dbf"][4])
print("gradients[\"dbf\"].shape =", gradients["dbf"].shape)
print("gradients[\"dbi\"][4] =", gradients["dbi"][4])
print("gradients[\"dbi\"].shape =", gradients["dbi"].shape)
print("gradients[\"dbc\"][4] =", gradients["dbc"][4])
print("gradients[\"dbc\"].shape =", gradients["dbc"].shape)
print("gradients[\"dbo\"][4] =", gradients["dbo"][4])
print("gradients[\"dbo\"].shape =", gradients["dbo"].shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

测试结果如下：

gradients["dx"][1][2] = [-0.00720326 -0.41485675 -0.47430604  0.14211684]
gradients["dx"].shape = (3, 10, 4)
gradients["da0"][2][3] = -0.09591150195400472
gradients["da0"].shape = (5, 10)
gradients["dWf"][3][1] = -0.06981985612744011
gradients["dWf"].shape = (5, 8)
gradients["dWi"][1][2] = 0.10237182024854774
gradients["dWi"].shape = (5, 8)
gradients["dWc"][3][1] = -0.062498379492745254
gradients["dWc"].shape = (5, 8)
gradients["dWo"][1][2] = 0.04843891314443011
gradients["dWo"].shape = (5, 8)
gradients["dbf"][4] = [-0.0565788]
gradients["dbf"].shape = (5, 1)
gradients["dbi"][4] = [-0.15399065]
gradients["dbi"].shape = (5, 1)
gradients["dbc"][4] = [-0.29691142]
gradients["dbc"].shape = (5, 1)
gradients["dbo"][4] = [-0.29798344]
gradients["dbo"].shape = (5, 1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

二、字符级语言模型-恐龙岛

欢迎来到恐龙岛，恐龙生活于在6500万年前，现在研究人员在试着复活恐龙，而你的任务就是给恐龙命名，如果一只恐龙不喜欢它的名字，它可能会狂躁不安，所以你要谨慎选择。

你的助手已经收集了他们能够找到的所有恐龙名字，并编入了这个数据集,为了构建字符级语言模型来生成新的名称，你的模型将学习不同的名称模式，并随机生成新的名字。希望这个算法能让你和你的团队远离恐龙的愤怒。
在这里你将学习到：

• 如何存储文本数据以便使用 RNN 进行处理
• 如何合成数据，通过每次采样预测，并将其传递给下一个 RNN 单元
• 如何构建字符级文本生成 RNN
• 为什么梯度修剪很重要？

1. 数据预处理和模型回顾

（1）数据集与预处理

import numpy as np
import random
import time
import cllm_utils
1
2
3
4

我们先来读取恐龙名称的数据集，创建一个唯一字符列表（如 A、Z），并计算数据集和词汇量的大小。

# 获取数据，将txt文件的所有内容读入到字符串data中
data = open('../data/dinos.txt', 'r').read()

# 转化为小写字符
data = data.lower()

# 转化为无序且不重复的元素列表
chars = list(set(data))

# 获取大小信息
data_size, vocab_size = len(data), len(chars)

print(chars)
print("共计有%d个字符，唯一字符有%d个"%(data_size,vocab_size))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出结果为：

['c', 'j', '\n', 'l', 'h', 'o', 'i', 's', 'w', 'r', 'p', 'g', 'z', 'x', 'q', 'n', 'k', 'a', 'm', 'y', 't', 'u', 'b', 'v', 'f', 'e', 'd']
共计有19909个字符，唯一字符有27个
1
2

这些字符是 a-z（26个英文字符）加上 \n（换行符），在这里 \n 起到了类似 EOS（句子结尾）的作用，这里表示了名字的结束而不是句子的结尾。下面我们将创建字典 char_to_ix，将每个字符映射到 0-26 的索引，然后再创建字典 ix_to_char，将每个索引映射回相应的字符，它回帮助我们找出 softmax 层的概率分布输出中的字符。

# enumerate将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标
char_to_ix = {ch:i for i, ch in enumerate(sorted(chars))}
ix_to_char = {i:ch for i, ch in enumerate(sorted(chars))}

print(char_to_ix)
print(ix_to_char)
1
2
3
4
5
6

输出结果为：

{'\n': 0, 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 10, 'k': 11, 'l': 12, 'm': 13, 'n': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20, 'u': 21, 'v': 22, 'w': 23, 'x': 24, 'y': 25, 'z': 26}
{0: '\n', 1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z'}
1
2

（2）模型回顾

在之前我们构建的循环神经网络模型结构如下：

• 初始化参数
• 循环：
  • 前向传播计算损失
  • 反向传播计算关于损失的梯度
  • 修剪梯度以免梯度爆炸
  • 用梯度下降更新规则更新参数
• 返回学习后的参数
  
  在每个时间步，RNN 会预测给定字符的下一个字符是什么。数据集 $\text{X}=({\text{x}}^{<1>},{\text{x}}^{<2>},...,{\text{x}}^{<T_{\text{x}}>})$ 是一个列表类型的字符训练集，同时 $\text{Y}=({\text{y}}^{<1>},{\text{y}}^{<2>},...,{\text{y}}^{<T_{\text{x}}>})$ 在每个时间步 $\text{t}$ 亦是如此，因此，${\text{y}}^{<t>}={\text{x}}^{<t+1>}$。

2. 构建模型中的模块

在这部分，我们将来构建整个模型中的两个重要的模块：

• 梯度修剪：避免梯度爆炸
• 取样：一种用来生产字符的技术

（1）梯度修建

在这里，我们将实现在优化循环中调用的clip函数。回想一下，整个循环结构通常包括前向传播、成本计算、反向传播和参数更新。在更新参数之前，我们将在需要时执行梯度修剪，以确保我们的梯度不是“爆炸”的。

接下来我们将实现一个修剪函数，该函数输入一个梯度字典输出一个已经修剪过了的梯度。有很多的方法来修剪梯度，我们在这里使用一个比较简单的方法。梯度向量的每一个元素都被限制在 $[-N，N]$ 的范围，通俗的说，有一个 maxValue（比如10），如果梯度的任何值大于10，那么它将被设置为10，如果梯度的任何值小于-10，那么它将被设置为-10，如果它在-10与10之间，那么它将不变。

我们来实现下面的函数来返回一个修剪过后的梯度字典，函数接受最大阈值，并返回修剪后的梯度。

def clip(gradients, maxValue):
    """
    使用maxValue来修剪梯度
    
    参数：
        gradients -- 字典类型，包含了以下参数："dWaa", "dWax", "dWya", "db", "dby"
        maxValue -- 阈值，把梯度值限制在[-maxValue, maxValue]内
        
    返回：
        gradients -- 修剪后的梯度
    """
    # 获取参数
    dWaa, dWax, dWya, db, dby = gradients['dWaa'], gradients['dWax'], gradients['dWya'], gradients['db'], gradients['dby']
    
    # 梯度修剪
    for gradient in [dWaa, dWax, dWya, db, dby]:
        np.clip(gradient, -maxValue, maxValue, out=gradient)

    gradients = {"dWaa": dWaa, "dWax": dWax, "dWya": dWya, "db": db, "dby": dby}
    
    return gradients
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

测试：

np.random.seed(3)
dWax = np.random.randn(5,3)*10
dWaa = np.random.randn(5,5)*10
dWya = np.random.randn(2,5)*10
db = np.random.randn(5,1)*10
dby = np.random.randn(2,1)*10
gradients = {"dWax": dWax, "dWaa": dWaa, "dWya": dWya, "db": db, "dby": dby}
gradients = clip(gradients, 10)
print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2])
print("gradients[\"dWax\"][3][1] =", gradients["dWax"][3][1])
print("gradients[\"dWya\"][1][2] =", gradients["dWya"][1][2])
print("gradients[\"db\"][4] =", gradients["db"][4])
print("gradients[\"dby\"][1] =", gradients["dby"][1])
1
2
3
4
5
6
7
8
9
10
11
12
13

测试结果如下：

gradients["dWaa"][1][2] = 10.0
gradients["dWax"][3][1] = -10.0
gradients["dWya"][1][2] = 0.2971381536101662
gradients["db"][4] = [10.]
gradients["dby"][1] = [8.45833407]
1
2
3
4
5

（2）采样

现在假设我们的模型已经训练过了，我们希望生成新的文本，生成的过程如下图：

这里的 sample 函数由以下四步构成：

• 步骤1：网络的 ${\text{x}}^{<1>}=\vec{0}$（零向量），这是在生成字符之前的默认输入，同时我们设置 ${\text{a}}^{<0>}=\vec{0}$
• 步骤2：运行一次前向传播，然后得到 ${\text{a}}^{<1>}$ 与 ${\hat{\text{y}}}^{<1>}$。公式如下：$${\text{a}}^{<t+1>}=\text{tanh}(W_{\text{ax}}{\text{x}}^{<t>}+W_{\text{aa}}{\text{a}}^{<t>}+b)$$$${\text{z}}^{<t+1>}=W_{\text{ya}}{\text{a}}^{<t+1>}+{\text{b}}_{\text{y}}$$$${\hat{\text{y}}}^{<t+1>}=\text{softmax}({\text{z}}^{<t+1>})$$需要注意的是 ${\hat{\text{y}}}^{<t+1>}$ 是一个 softmax 概率向量（其值在 0-1 之间，总和为1），${\hat{\text{y}}}_i^{<t+1>}$ 表示索引为 $i$ 的字符是下一个字符的概率。
• 步骤3：根据 ${\hat{\text{y}}}^{<t+1>}$ 指定的概率分布选择下一个字符的索引，加入 ${\hat{\text{y}}}_i^{<t+1>}=0.16$，那么选择索引 $i$ 的概率为 0.16，为了实现它，我们可以使用 np.random.choice 函数，下面是 np.random.choice 使用的例子：

np.random.seed(0)
p = np.array([0.1, 0.0, 0.7, 0.2])    # 取各个值的概率
index = np.random.choice([0, 1, 2, 3], p = p.ravel())  # p.ravel()将其展开为一维数组
1
2
3

• 步骤4：用 ${\text{x}}^{<t+1>}$ 的值覆盖变量 $\text{x}$（当前存储 ${\text{x}}^{<t>}$）。我们将通过创建一个与我们所选择的字符相对应的一个独热向量来表示 ${\text{x}}^{<t+1>}$。然后在步骤1中像前传播 ${\text{x}}^{<t+1>}$，并不断重复这个过程，直到得到一个 ‘\n’ 字符，表明已经到达恐龙名称的末尾。

def sample(parameters, char_to_is, seed):
    """
    根据RNN输出的概率分布序列对字符序列进行采样
    
    参数：
        parameters -- 包含了Waa, Wax, Wya, by, b的字典
        char_to_ix -- 字符映射到索引的字典
        seed -- 随机种子
        
    返回：
        indices -- 包含采样字符索引的长度为n的列表。
    """
    # 从 parameters 中获取参数
    Waa, Wax, Wya, by, b = parameters['Waa'], parameters['Wax'], parameters['Wya'], parameters['by'], parameters['b']
    vocab_size = by.shape[0]
    n_a = Waa.shape[1]
    
    # 步骤1
    ## 创建独热向量 x
    x = np.zeros((vocab_size, 1))
    
    ## 使用 0 初始化 a_prev
    a_prev = np.zeros((n_a, 1))
    
    # 创建索引的空列表，这是包含要生成的字符的索引的列表
    indices = []
    
    # IDX 是检测换行符的标志，我们将其初始化为 -1
    idx = -1
    
    # 循环遍历时间步骤t。在每个时间步中，从概率分布中抽取一个字符
    # 并将其索引附加到“indices”上，如果我们达到50个字符
    # 我们应该不太可能有一个训练好的模型，我们将停止循环，这有助于调试并防止进入无限循环
    counter = 0
    newline_character = char_to_ix["\n"]
    
    while(idx != newline_character and counter < 50):
        # 步骤2：使用上述公式进行前向传播
        a = np.tanh(np.dot(Wax, x) + np.dot(Waa, a_prev) + b)
        z = np.dot(Wya, a) + by
        y = cllm_utils.softmax(z)
        
        # 设定随机种子
        np.random.seed(counter + seed)
        
        # 步骤3：从概率分布 y 中抽取词汇表中字符的索引
        idx = np.random.choice(list(range(vocab_size)), p=y.ravel())
        
        # 添加到索引中
        indices.append(idx)
        
        # 步骤4：将输入字符重写为与采样索引对应的字符
        x = np.zeros((vocab_size, 1))
        x[idx] = 1
        
        # 更新 a_prev 为a
        a_prev = a
        
        # 累加器
        seed += 1
        counter += 1
        
    if(counter == 50):
        indices.append(char_to_ix["\n"])
        
    return indices 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

测试：

np.random.seed(2)
_, n_a = 20, 100
Wax, Waa, Wya = np.random.randn(n_a, vocab_size), np.random.randn(n_a, n_a), np.random.randn(vocab_size, n_a)
b, by = np.random.randn(n_a, 1), np.random.randn(vocab_size, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b, "by": by}


indices = sample(parameters, char_to_ix, 0)
print("Sampling:")
print("list of sampled indices:", indices)
print("list of sampled characters:", [ix_to_char[i] for i in indices])
1
2
3
4
5
6
7
8
9
10
11

测试结果如下：

Sampling:
list of sampled indices: [12, 17, 24, 14, 13, 9, 10, 22, 24, 6, 13, 11, 12, 6, 21, 15, 21, 14, 3, 2, 1, 21, 18, 24, 7, 25, 6, 25, 18, 10, 16, 2, 3, 8, 15, 12, 11, 7, 1, 12, 10, 2, 7, 7, 11, 17, 24, 12, 3, 1, 0]
list of sampled characters: ['l', 'q', 'x', 'n', 'm', 'i', 'j', 'v', 'x', 'f', 'm', 'k', 'l', 'f', 'u', 'o', 'u', 'n', 'c', 'b', 'a', 'u', 'r', 'x', 'g', 'y', 'f', 'y', 'r', 'j', 'p', 'b', 'c', 'h', 'o', 'l', 'k', 'g', 'a', 'l', 'j', 'b', 'g', 'g', 'k', 'q', 'x', 'l', 'c', 'a', '\n']
1
2
3

3. 构建语言模型

（1）梯度下降

在这里，我们将实现一个执行随机梯度下降的一个步骤的函数（带有梯度修剪）。我们将一次训练一个样本，所以优化算法将是随机梯度下降，这里是 RNN 的一个通用的优化循环的步骤：

• 前向传播计算损失
• 反向传播计算关于参数的梯度损失
• 修剪梯度
• 使用梯度下降更新参数
  我们来实现这一优化过程（单步随机梯度下降），这里我们提供了一些函数（在 cllm_utils 里提供了相应的函数实现）：

# 示例，仅供参考，请勿执行
def rnn_forward(X, Y, a_prev, parameters):
    """
    通过RNN进行前向传播，计算交叉熵损失。

    它返回损失的值以及存储在反向传播中使用的“缓存”值。
    """
    ....
    return loss, cache
    
def rnn_backward(X, Y, parameters, cache):
    """ 
    通过时间进行反向传播，计算相对于参数的梯度损失。它还返回所有隐藏的状态
    """
    ...
    return gradients, a

def update_parameters(parameters, gradients, learning_rate):
    """
    Updates parameters using the Gradient Descent Update Rule
    """
    ...
    return parameters
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

我们来构建优化函数：

def optimize(X, Y, a_prev, parameters, learning_rate = 0.01):
    """
    执行训练模型的单步优化。
    
    参数：
        X -- 整数列表，其中每个整数映射到词汇表中的字符。
        Y -- 整数列表，与X完全相同，但向左移动了一个索引。
        a_prev -- 上一个隐藏状态
        parameters -- 字典，包含了以下参数：
                        Wax -- 权重矩阵乘以输入，维度为(n_a, n_x)
                        Waa -- 权重矩阵乘以隐藏状态，维度为(n_a, n_a)
                        Wya -- 隐藏状态与输出相关的权重矩阵，维度为(n_y, n_a)
                        b -- 偏置，维度为(n_a, 1)
                        by -- 隐藏状态与输出相关的权重偏置，维度为(n_y, 1)
        learning_rate -- 模型学习的速率
    
    返回：
        loss -- 损失函数的值（交叉熵损失）
        gradients -- 字典，包含了以下参数：
                        dWax -- 输入到隐藏的权值的梯度，维度为(n_a, n_x)
                        dWaa -- 隐藏到隐藏的权值的梯度，维度为(n_a, n_a)
                        dWya -- 隐藏到输出的权值的梯度，维度为(n_y, n_a)
                        db -- 偏置的梯度，维度为(n_a, 1)
                        dby -- 输出偏置向量的梯度，维度为(n_y, 1)
        a[len(X)-1] -- 最后的隐藏状态，维度为(n_a, 1)
    """
    
    # 前向传播
    loss, cache = cllm_utils.rnn_forward(X, Y, a_prev, parameters)
    
    # 反向传播
    gradients, a = cllm_utils.rnn_backward(X, Y, parameters, cache)
    
    # 梯度修剪，[-5 , 5]
    gradients = clip(gradients,5)
    
    # 更新参数
    parameters = cllm_utils.update_parameters(parameters,gradients,learning_rate)
    
    return loss, gradients, a[len(X)-1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

测试：

np.random.seed(1)
vocab_size, n_a = 27, 100
a_prev = np.random.randn(n_a, 1)
Wax, Waa, Wya = np.random.randn(n_a, vocab_size), np.random.randn(n_a, n_a), np.random.randn(vocab_size, n_a)
b, by = np.random.randn(n_a, 1), np.random.randn(vocab_size, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b, "by": by}
X = [12,3,5,11,22,3]
Y = [4,14,11,22,25, 26]

loss, gradients, a_last = optimize(X, Y, a_prev, parameters, learning_rate = 0.01)
print("Loss =", loss)
print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2])
print("np.argmax(gradients[\"dWax\"]) =", np.argmax(gradients["dWax"]))
print("gradients[\"dWya\"][1][2] =", gradients["dWya"][1][2])
print("gradients[\"db\"][4] =", gradients["db"][4])
print("gradients[\"dby\"][1] =", gradients["dby"][1])
print("a_last[4] =", a_last[4])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

测试结果如下：

Loss = 126.50397572165345
gradients["dWaa"][1][2] = 0.19470931534725341
np.argmax(gradients["dWax"]) = 93
gradients["dWya"][1][2] = -0.007773876032004315
gradients["db"][4] = [-0.06809825]
gradients["dby"][1] = [0.01538192]
a_last[4] = [-1.]
1
2
3
4
5
6
7

（2）训练模型

给定恐龙名称的数据集，我们使用数据集的每一行（一个名称）作为一个训练样本。每 100 步随机梯度下降，你将抽样10 个随机选择的名字，看看算法是怎么做的。记住要打乱数据集，以便随机梯度下降以随即顺序访问样本。当 example[index] 包含一个恐龙名称（String）时，为了创建一个样本（X，Y），你可以使用如下代码：

index = j % len(examples)
X = [None] + [char_to_ix[ch] for ch in examples[index]] 
Y = X[1:] + [char_to_ix["\n"]]
1
2
3

需要注意的是我们使用了 index= j % len(examples)，其中 j=1....num_iterations，这样做是为了确保 index 总是有效的（index < len(examples)），rnn_forward() 会将 X 的第一个值 None 解释为 $x^{<0>}=\vec{0}$。此外，为了确保 Y=X，我们会将 Y 向左移动一步，并添加一个附加的 \n 以表示恐龙名称的结束。
下面我们举个例子来看看上述三条语句的具体含义是什么：

examples = ["aachenosaurus", "brachylophosaurus", "camarillasaurus"]
index = 5 % len(examples)
X = [None] + [char_to_ix[ch] for ch in examples[index]]  # 列表的拼接
print('X=', X)
Y = X[1:] + [char_to_ix["\n"]]
print('Y=', Y)
1
2
3
4
5
6

输出结果为：

X= [None, 3, 1, 13, 1, 18, 9, 12, 12, 1, 19, 1, 21, 18, 21, 19]
Y= [3, 1, 13, 1, 18, 9, 12, 12, 1, 19, 1, 21, 18, 21, 19, 0]
1
2

接下来，让我们开始实现模型吧。

def model(data, ix_to_char, char_to_ix, num_iterations=3500, 
          n_a=50, dino_names=7,vocab_size=27):
    """
    训练模型并生成恐龙名字
    
    参数：
        data -- 语料库
        ix_to_char -- 索引映射字符字典
        char_to_ix -- 字符映射索引字典
        num_iterations -- 迭代次数
        n_a -- RNN单元数量
        dino_names -- 每次迭代中采样的数量
        vocab_size -- 在文本中的唯一字符的数量
    
    返回：
        parameters -- 学习后了的参数
    """
    
    # 从vocab_size中获取n_x、n_y
    n_x, n_y = vocab_size, vocab_size
    
    # 初始化参数
    parameters = cllm_utils.initialize_parameters(n_a, n_x, n_y)
    
    # 初始化损失
    loss = cllm_utils.get_initial_loss(vocab_size, dino_names)
    
    # 构建恐龙名称列表
    with open("../data/dinos.txt") as f:
        examples = f.readlines()
    examples = [x.lower().strip() for x in examples] # 转为小写并删除空格
    
    # 打乱全部的恐龙名称
    np.random.seed(0)
    np.random.shuffle(examples)
    
    # 初始化LSTM隐藏状态
    a_prev = np.zeros((n_a,1))
    
    # 循环
    for j in range(num_iterations):
        # 定义一个训练样本
        index = j % len(examples)
        X = [None] + [char_to_ix[ch] for ch in examples[index]] 
        Y = X[1:] + [char_to_ix["\n"]]
        
        # 执行单步优化：前向传播 -> 反向传播 -> 梯度修剪 -> 更新参数
        # 选择学习率为0.01
        curr_loss, gradients, a_prev = optimize(X, Y, a_prev, parameters)
        
        # 使用延迟来保持损失平滑,这是为了加速训练。
        loss = cllm_utils.smooth(loss, curr_loss)
        
        # 每2000次迭代，通过sample()生成“\n”字符，检查模型是否学习正确
        if j % 2000 == 0:
            print("第" + str(j+1) + "次迭代，损失值为：" + str(loss))
            
            seed = 0
            for name in range(dino_names):
                # 采样
                sampled_indices = sample(parameters, char_to_ix, seed)
                cllm_utils.print_sample(sampled_indices, ix_to_char)
                
                # 为了得到相同的效果，随机种子+1
                seed += 1
            
            print("\n")
    return parameters
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

我们来训练一下：

#开始时间
start_time = time.perf_counter()

#开始训练
parameters, loss = model(data, ix_to_char, char_to_ix, num_iterations=20000)

#结束时间
end_time = time.perf_counter()

#计算时差
minium = end_time - start_time

print("执行了：" + str(int(minium / 60)) + "分" + str(int(minium%60)) + "秒")
1
2
3
4
5
6
7
8
9
10
11
12
13

绘制图像：

import matplotlib.pyplot as plt

epoches = np.arange(20000)

plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.plot(epoches, loss)
plt.grid()
plt.show()
1
2
3
4
5
6
7
8
9