LLM架构解析：门控循环单元（GRU）（第三部分）—— 从基础原理到实践应用的深度探索

本专栏深入探究从循环神经网络（RNN）到Transformer等自然语言处理（NLP）模型的架构，以及基于这些模型构建的应用程序。

本系列文章内容：

1. NLP自然语言处理基础
2. 词嵌入（Word Embeddings）
3. 循环神经网络（RNN）、长短期记忆网络（LSTM）和门控循环单元（GRU）
   3.1 循环神经网络（RNN）
   3.2 长短期记忆网络（LSTM）
   3.3 门控循环单元（GRU）（本文）
4. 编码器 - 解码器架构（Encoder - Decoder Architecture）
5. 注意力机制（Attention Mechanism）
6. Transformer
7. 编写Transformer代码
8. 双向编码器表征来自Transformer（BERT）
9. 生成式预训练Transformer（GPT）
10. 大语言模型（LLama）
11. Mistral

---

1. 门控循环单元（GRUs）

门控循环单元（GRU）由赵（Cho）等人于2014年提出，旨在解决标准循环神经网络（RNN）面临的梯度消失问题。GRU与长短期记忆网络（LSTM）有许多共同特性。这两种算法都采用门控机制来控制记忆过程。

想象一下，你正通过反复聆听来学习一首歌。一个基本的RNN可能在听到歌曲结尾时就忘记了开头。GRU通过使用门来解决这个问题，这些门可以控制哪些信息被记住，哪些被遗忘。

GRU通过将输入门和遗忘门合并为一个更新门，并增加一个重置门，简化了长短期记忆网络（LSTM）的结构。这使得GRU训练速度更快，更易于使用，同时仍能长时间记住重要信息。

• 更新门：该门决定了有多少过去的信息应该被传递到未来。
• 重置门：该门决定了要遗忘多少过去的信息。

这些门帮助GRU在记住重要细节和遗忘不重要信息之间保持平衡，就像你在听一首歌时，可能会专注于记住旋律而忽略背景噪音一样。

GRU非常适合处理序列数据的任务，比如预测股市、理解语言，甚至生成音乐。它们可以通过跟踪过去的信息并利用这些信息进行更好的预测，从而学习数据中的模式。这使得它们在任何需要理解先前数据点上下文的应用中都非常有用。

1.1 与LSTM和普通RNN的比较

为了了解GRU的适用场景，让我们将它们与LSTM和普通RNN进行比较。

普通RNN

可以把普通RNN看作是循环神经网络的基本版本。它们的工作方式是将信息从一个时间步传递到下一个时间步，就像接力赛中每个跑步者将接力棒传递给下一个人一样。然而，它们有一个很大的缺陷：在处理长序列时容易遗忘信息。这是由于梯度消失问题，使得它们难以学习数据中的长期依赖关系。

LSTM

长短期记忆网络就是为解决这个问题而设计的。它们采用了一种更复杂的结构，包含三种类型的门：输入门、遗忘门和输出门。这些门就像一个精密的文件管理系统，决定了哪些信息需要保留、哪些需要更新以及哪些需要丢弃。这使得LSTM能够长时间记住重要信息，非常适合那些需要考虑多个时间步上下文的任务，比如理解段落文本或识别长序列时间数据中的模式。

GRU

门控循环单元是LSTM的简化版本。它们通过将输入门和遗忘门合并为一个更新门，并增加一个重置门来简化结构。这使得GRU在计算上比LSTM的开销更小，训练速度更快，同时仍能有效处理长期依赖关系。

1.2 GRU为何特殊且比传统RNN更有效？

GRU支持门控和隐藏状态，以控制信息的流动。为了解决RNN中出现的问题，GRU使用了两个门：更新门和重置门。

可以将它们看作是两个向量元素（0，1），能够进行凸组合。这些组合决定了哪些隐藏状态信息需要更新（传递），或者在需要时重置隐藏状态。同样，网络学会跳过无关的临时观测值。

LSTM由三个门组成：输入门、遗忘门和输出门。与LSTM不同，GRU没有输出门，而是将输入门和遗忘门合并为一个更新门。

让我们进一步了解更新门和重置门。

1.2.1 更新门

更新门（$z_t$）负责确定需要将多少先前信息（前一时间步）传递到下一个状态。它是一个重要的单元。下面的示意图展示了更新门的结构。

这里，$x_t$ 是输入到网络单元的向量。它与参数权重矩阵（$W_z$）相乘。$h(t-1)$ 中的 $t-1$ 表示它包含前一个单元的信息，并且它也与相应的权重相乘。接下来，将这些参数的值相加，并通过Sigmoid激活函数。在这里，Sigmoid函数会生成介于0和1之间的值。

1.2.2 重置门

重置门（$r_t$）用于让模型决定需要忽略多少过去的信息。其公式与更新门相同。不过，它们的权重和门的用途有所不同，这将在接下来的部分进行讨论。下面的示意图展示了重置门。

有两个输入，$x_t$ 和 $h_{t-1}$。将它们分别与各自的权重相乘，进行逐点相加，然后通过Sigmoid函数。

2. 门的实际应用

首先，重置门会将上一个时间步的相关信息存储到新的记忆内容中。然后，它将输入向量和隐藏状态分别与它们的权重相乘。接着，在重置门和先前隐藏状态的乘积之间进行元素级乘法（哈达玛积）。求和之后，对上述步骤的结果应用非线性激活函数，从而得到 (h’_t)。

设想这样一个场景，一位顾客对一家度假村进行评价：“我到达这里的时候已经是深夜了。” 在写了几行之后，这条评价以 “我在这里住得很愉快，因为房间很舒适，工作人员也很友好。” 结尾。为了判断这位顾客的满意度水平，你将需要评价的最后两行内容。模型会扫描整条评价直到结尾，并将重置门的向量值设置为接近 “0”。

这意味着它将忽略前面的内容，只关注最后的句子。

请参考下面的图示。

这是最后一步。在当前时间步的最终记忆中，网络需要计算 $h_t$。在这里，更新门将起到关键作用。这个向量值将保存当前单元的信息，并将其传递到网络中。它将决定从当前的记忆内容$h_t^{\prime }$和上一个时间步 $h_{t-1}$ 中收集哪些信息。对更新门和 $h_{t-1}$ 进行元素级乘法（哈达玛积），并将其与 $(1-z_t)$ 和 $h_t^{\prime }$ 之间的哈达玛积运算结果相加。

再回到度假村评价的例子：这次，用于预测的相关信息在文本的开头就被提到了。模型会将更新门的向量值设置为接近 1。在当前时间步，$1-z_t$ 将接近 0，它将忽略评价最后部分的内容。请参考下面的图片。

接着看，你可以看到 $z_t$ 被用于计算 $(1-z_t)$，$(1-z_t)$ 与 $h_t^{\prime }$ 结合以产生结果。在 $h_{t-1}$ 和 $z_t$ 之间进行哈达玛积运算。该乘积的输出作为输入，与 $h_t^{\prime }$ 进行逐元素相加，以在隐藏状态中产生最终结果。

3. 简单GRU的实现

为了巩固我们所涵盖的概念，让我们通过实践的方式，用Python从零开始实现一个基本的门控循环单元（GRU）。

下面的代码片段展示了一个简化的GRU类，突出了GRU架构中前向传播和反向传播的基本功能。

import numpy as np

class SimpleGRU:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        # 初始化权重和偏置
        self.W_z = np.random.randn(hidden_size, input_size)
        self.U_z = np.random.randn(hidden_size, hidden_size)
        self.b_z = np.zeros((hidden_size, 1))
        
        self.W_r = np.random.randn(hidden_size, input_size)
        self.U_r = np.random.randn(hidden_size, hidden_size)
        self.b_r = np.zeros((hidden_size, 1))
        
        self.W_h = np.random.randn(hidden_size, input_size)
        self.U_h = np.random.randn(hidden_size, hidden_size)
        self.b_h = np.zeros((hidden_size, 1))
        
        self.W_y = np.random.randn(output_size, hidden_size)
        self.b_y = np.zeros((output_size, 1))

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def tanh(self, x):
        return np.tanh(x)
    
    def softmax(self, x):
        exp_x = np.exp(x - np.max(x))
        return exp_x / exp_x.sum(axis=0, keepdims=True)

    def forward(self, x):
        T = len(x)
        h = np.zeros((self.hidden_size, 1))
        y_list = []

        for t in range(T):
            x_t = x[t].reshape(-1, 1)  # 将输入重塑为列向量

            # 更新门
            z = self.sigmoid(np.dot(self.W_z, x_t) + np.dot(self.U_z, h) + self.b_z)

            # 重置门
            r = self.sigmoid(np.dot(self.W_r, x_t) + np.dot(self.U_r, h) + self.b_r)

            # 候选隐藏状态
            h_tilde = self.tanh(np.dot(self.W_h, x_t) + np.dot(self.U_h, r * h) + self.b_h)

            # 隐藏状态更新
            h = (1 - z) * h + z * h_tilde

            # 输出
            y = np.dot(self.W_y, h) + self.b_y
            y_list.append(y)

        return y_list

    def backward(self, x, y_list, target):
        T = len(x)
        dW_z = np.zeros_like(self.W_z)
        dU_z = np.zeros_like(self.U_z)
        db_z = np.zeros_like(self.b_z)
        
        dW_r = np.zeros_like(self.W_r)
        dU_r = np.zeros_like(self.U_r)
        db_r = np.zeros_like(self.b_r)
        
        dW_h = np.zeros_like(self.W_h)
        dU_h = np.zeros_like(self.U_h)
        db_h = np.zeros_like(self.b_h)
        
        dW_y = np.zeros_like(self.W_y)
        db_y = np.zeros_like(self.b_y)
        
        dh_next = np.zeros_like(y_list[0])

        for t in reversed(range(T)):
            dy = y_list[t] - target[t]
            dW_y += np.dot(dy, np.transpose(h))
            db_y += dy
            
            dh = np.dot(np.transpose(self.W_y), dy) + dh_next
            
            dh_tilde = dh * (1 - self.sigmoid(np.dot(self.W_z, x[t].reshape(-1, 1)) + np.dot(self.U_z, h) + self.b_z))
            dW_h += np.dot(dh_tilde, np.transpose(x[t].reshape(1, -1)))
            db_h += dh_tilde
            
            dr = np.dot(np.transpose(self.W_h), dh_tilde)
            dU_h += np.dot(dr * h * (1 - self.tanh(np.dot(self.W_h, x[t].reshape(-1, 1)) + np.dot(self.U_h, r * h) + self.b_h)), np.transpose(h))
            dW_h += np.dot(dr * h * (1 - self.tanh(np.dot(self.W_h, x[t].reshape(-1, 1)) + np.dot(self.U_h, r * h) + self.b_h)), np.transpose(x[t].reshape(1, -1)))
            db_h += dr * h * (1 - self.tanh(np.dot(self.W_h, x[t].reshape(-1, 1)) + np.dot(self.U_h, r * h) + self.b_h))
            
            dz = np.dot(np.transpose(self.U_r), dr * h * (self.tanh(np.dot(self.W_h, x[t].reshape(-1, 1)) + np.dot(self.U_h, r * h) + self.b_h) - h_tilde))
            dU_z += np.dot(dz * h * z * (1 - z), np.transpose(h))
            dW_z += np.dot(dz * h * z * (1 - z), np.transpose(x[t].reshape(1, -1)))
            db_z += dz * h * z * (1 - z)
            
            dh_next = np.dot(np.transpose(self.U_z), dz * h * z * (1 - z))
        
        return dW_z, dU_z, db_z, dW_r, dU_r, db_r, dW_h, dU_h, db_h, dW_y, db_y

    def update_parameters(self, dW_z, dU_z, db_z, dW_r, dU_r, db_r, dW_h, dU_h, db_h, dW_y, db_y, learning_rate):
        self.W_z -= learning_rate * dW_z
        self.U_z -= learning_rate * dU_z
        self.b_z -= learning_rate * db_z
        
        self.W_r -= learning_rate * dW_r
        self.U_r -= learning_rate * dU_r
        self.b_r -= learning_rate * db_r
        
        self.W_h -= learning_rate * dW_h
        self.U_h -= learning_rate * dU_h
        self.b_h -= learning_rate * db_h
        
        self.W_y -= learning_rate * dW_y
        self.b_y -= learning_rate * db_y

# 示例用法
input_size = 4
hidden_size = 3
output_size = 2

gru = SimpleGRU(input_size, hidden_size, output_size)

# 生成随机数据
sequence_length = 5
data = [np.random.randn(input_size) for _ in range(sequence_length)]
target = [np.random.randn(output_size) for _ in range(sequence_length)]

# 前向传播
y_list = gru.forward(data)

# 反向传播
dW_z, dU_z, db_z, dW_r, dU_r, db_r, dW_h, dU_h, db_h, dW_y, db_y = gru.backward(data, y_list, target)

# 更新权重和偏置
learning_rate = 0.1
gru.update_parameters(dW_z, dU_z, db_z, dW_r, dU_r, db_r, dW_h, dU_h, db_h, dW_y, db_y, learning_rate)

在上述实现中，我们引入了一个简化的 SimpleGRU 类，以深入了解GRU的核心机制。示例用法展示了如何初始化GRU，为输入序列和目标输出创建随机数据，执行前向传播和反向传播，然后使用计算得到的梯度更新权重和偏置。

3.1 GRU的优缺点

GRU的优点

• 序列数据建模：GRU在处理序列数据方面表现出色，使其非常适合自然语言处理、语音识别和时间序列分析等任务。
• 可变长度输入：GRU可以处理不同长度的序列，适用于输入大小各异的应用场景。
• 计算效率高：与LSTM等更复杂的循环架构相比，由于其设计更简单，GRU在计算上往往更高效。
• 缓解梯度消失问题：GRU比传统的RNN更有效地解决了梯度消失问题，使其能够捕捉数据中的长期依赖关系。

GRU的局限性

• 长期记忆有限：虽然GRU在捕捉长期依赖关系方面比标准RNN更好，但对于具有复杂依赖关系的非常长的序列，它们可能不如LSTM有效。
• 表达能力较弱：在某些情况下，GRU可能无法像LSTM那样有效地捕捉复杂的模式，特别是在对高度复杂的序列进行建模时。
• 特定应用场景：对于需要显式内存控制或复杂上下文建模的任务，LSTM或更先进的架构可能更合适。

3.2 在GRU和LSTM之间进行选择

使用门控循环单元（GRU）还是长短期记忆（LSTM）网络的决策取决于你具体的问题和数据集。以下是一些需要考虑的因素：

适合使用GRU的情况：

• 计算资源有限：与LSTM相比，GRU的计算量较小，因此在存在资源限制的情况下，GRU是一个更优的选择。
• 模型简单性很重要：如果你想要一个更简单的模型，并且仍然能够较好地捕捉序列依赖关系，GRU是一个不错的选择。
• 处理较短序列：对于涉及依赖关系较短的序列的任务，GRU可以提供足够的性能，而无需LSTM复杂的内存管理。

适合使用LSTM的情况：

• 捕捉长期依赖关系：LSTM更适合那些捕捉长期依赖关系至关重要的任务，例如语言建模、语音识别和某些时间序列预测。
• 细粒度的内存控制：LSTM对内存提供了更明确的控制，因此在需要精确处理内存的情况下，LSTM是更好的选择。
• 处理复杂序列：如果你的数据表现出复杂的序列模式和依赖关系，LSTM通常在对这些复杂性进行建模时更有效。

在实践中，最好在你特定的任务上同时对GRU和LSTM进行实验，以确定哪种架构的性能更好。有时，两者之间的选择取决于对你的数据集进行的实证测试和验证。

4. 结论

在本文中，我们探讨了循环神经网络（RNN），深入研究了它们的核心机制、训练挑战以及能够提升其性能的先进设计。以下是一个快速回顾：

• 我们剖析了RNN的结构，强调了它们通过内部记忆状态处理序列的能力。讨论了前向传播和随时间反向传播（BPTT）等关键过程，解释了RNN如何处理序列数据。
• 我们还强调了主要的训练挑战，包括梯度消失和梯度爆炸问题，这些问题可能会干扰学习过程。为了解决这些问题，我们探索了梯度裁剪和初始化策略等解决方案，这些方法有助于稳定训练过程，并提高网络从较长序列中学习的能力。
• 门控循环单元（GRU）是RNN的一种强大变体，旨在高效地处理序列数据。它们有效地缓解了梯度消失等问题，并擅长捕捉序列中的依赖关系，使其成为自然语言处理、语音识别和时间序列分析等任务的理想选择。
• GRU使用门控机制来控制信息的流动，使其能够在保持计算效率的同时捕捉长期依赖关系。理解GRU背后的架构和数学原理是在机器学习任务中有效利用它们的关键。
• 在GRU和LSTM之间进行选择时，有几个因素需要考虑，包括数据的复杂性、计算资源以及要建模的依赖关系的长度。这两种架构都有其优缺点，因此最佳选择取决于你任务的具体要求。

5. 检验你的知识！

1. 你能解释一下损失函数和优化器在神经网络训练中的作用吗？特别是在反向传播和梯度下降过程中它们是如何相互作用的？
   • 预期答案：损失函数衡量预测输出和实际输出之间的差异。在反向传播过程中，计算关于每个权重的损失梯度。优化器，如Adam或随机梯度下降（SGD），使用这些梯度来更新权重。梯度下降确保模型朝着最优权重的方向移动，但根据架构和深度的不同，可能会出现梯度消失或梯度爆炸等问题。
2. 为什么较小的批量大小会导致更具噪声的梯度更新？批量大小和计算效率之间的权衡是什么？
   • 预期答案：较小的批量大小会导致更具噪声的梯度，因为每个批量可能无法很好地代表整个数据分布，这可能会导致更随机的更新。然而，这种噪声也可以帮助模型逃离局部最小值。权衡在于，较小的批量大小可能会由于更频繁的更新而增加训练时间，但它们会减少内存需求，并且可能具有更好的泛化能力。
3. 卷积神经网络（CNN）与循环神经网络（RNN）有何不同？每种架构最适合哪些类型的问题？
   • 预期答案：CNN主要用于处理空间数据（如图像），其中局部连接和权重共享使它们能够高效地检测图像中的模式。另一方面，RNN是为处理序列数据（如时间序列或自然语言）而设计的，在这些数据中时间依赖关系很重要。CNN在维护序列上下文方面是无效的，而这对于像语言建模或序列预测这样的RNN任务至关重要。
4. 在RNN中处理序列数据，特别是长序列时，存在哪些固有的挑战？
   • 预期答案：RNN在处理长序列时会遇到梯度消失问题，即随着梯度在时间上反向传播，梯度会呈指数级缩小。这使得网络很难学习长期依赖关系。此外，网络可能会对较新的输入产生偏差，而忽略早期的相关信息。
5. 你能解释为什么对于序列任务，RNN是比前馈神经网络更好的选择吗？它们在处理信息方面有何不同？
   • 预期答案：前馈网络独立地处理所有输入，因此无法捕捉时间依赖关系。相比之下，RNN在时间步之间保持一个隐藏状态，使其能够从先前的输入中学习，这对于像语言建模或时间序列预测这样的任务至关重要。这种保持对过去数据“记忆”的能力使RNN在序列任务中具有优势。
6. RNN如何处理可变长度的输入序列？填充对RNN的性能有什么影响？
   • 预期答案：RNN可以通过一次处理一个时间步来处理可变长度的输入序列。然而，填充用于将输入长度标准化以便进行批量处理，这会引入额外的步骤，在这些步骤中不存在有意义的信息。这可能会导致效率低下，因为模型可能会浪费资源来处理填充的步骤。注意力机制或掩码损失函数通常用于解决这个问题。
7. 对RNN进行时间展开是什么意思？它对训练和反向传播的复杂性有什么影响？
   • 预期答案：对RNN进行时间展开意味着在时间步上表示网络，其中每个时间步对应于一个循环层。这导致每个层在时间步之间共享相同的权重。随着序列长度的增加，计算复杂性会显著增加，由于梯度爆炸和梯度消失等问题，使得训练更具挑战性。计算梯度需要使用随时间反向传播（BPTT），这会增加内存和计算需求。
8. 执行随时间反向传播（BPTT）的主要挑战是什么？它与标准反向传播有何不同？
   • 预期答案：BPTT的关键挑战是它必须在多个时间步上传播梯度，这可能会加剧梯度消失或梯度爆炸等问题。与标准反向传播不同，BPTT在时间序列上操作，这会增加内存消耗和计算复杂性。为了解决这个问题，会使用截断BPTT等技术，即梯度仅在有限数量的时间步上传播。
9. RNN中梯度消失和梯度爆炸问题是由什么引起的？在训练过程中如何诊断这些问题？
   • 预期答案：梯度消失问题发生在梯度变得太小时，特别是在深度网络中，这使得模型很难学习长期依赖关系。梯度爆炸问题则是当梯度呈指数级增长时出现，导致权重更新不稳定。可以通过在训练过程中监控梯度来诊断这些问题——如果梯度变得非常小或非常大，这就是这些问题的一个指标。
10. 你如何识别你的RNN是否存在梯度消失或梯度爆炸问题？你会采取哪些步骤来解决这个问题？
    • 预期答案：你可以通过在训练过程中跟踪梯度的大小来识别梯度消失或梯度爆炸问题。如果梯度倾向于减小到零或不受控制地增长，这就是梯度问题的一个迹象。解决方案包括使用梯度裁剪（针对梯度爆炸）等技术，采用像LSTM或GRU这样的架构（有助于缓解梯度消失问题），以及选择合适的激活函数，如ReLU或其变体。
11. 为什么LSTM在处理长期依赖关系方面比普通RNN更有效？它们是如何解决梯度消失问题的？
    • 预期答案：LSTM配备了一个记忆单元，可以在很长的时间间隔内保持信息。LSTM中的遗忘门、输入门和输出门控制信息的流动，使它们能够保留相关信息，同时丢弃不相关的数据。这些门帮助LSTM解决梯度消失问题，确保记忆单元保留对长期依赖关系重要的信息，同时仍然允许有意义的梯度进行反向传播。
12. 解释一下LSTM中的遗忘门、输入门和输出门是如何工作的。
    • 预期答案：遗忘门决定应该从记忆单元中丢弃哪些信息。输入门确定应该添加哪些新信息。输出门控制当前单元状态中的哪些信息应该用作下一个时间步的隐藏状态。这些门结合在一起，使LSTM能够在长序列中有效地维护、更新和输出信息。
13. GRU与LSTM有何不同？在哪些场景中你会更倾向于使用GRU而不是LSTM？
    • 预期答案：与LSTM相比，GRU具有更简单的架构。它们将遗忘门和输入门合并为一个“更新门”，并且没有明确的记忆单元。这使得GRU速度更快，计算成本更低，并且在许多任务中表现相似。当训练数据有限或计算效率是首要考虑因素时，通常更倾向于使用GRU。
14. 从零开始实现RNN或LSTM在梯度计算、训练时间和优化方面的关键挑战是什么？
    • 预期答案：实现RNN或LSTM需要仔细处理跨时间步的梯度流动，由于随时间反向传播（BPTT），这在计算上可能很昂贵。处理梯度消失或梯度爆炸问题是一个重大挑战。优化训练时间需要仔细调整超参数，如学习率、批量大小和序列长度。此外，确保架构能够在各种类型的序列数据上具有良好的泛化能力，需要有效的正则化技术，如Dropout。
15. 梯度裁剪如何帮助缓解RNN中的梯度爆炸问题？在实践中你将如何实现它？
    • 预期答案：梯度裁剪在反向传播过程中限制梯度的大小，以防止它们变得太大并使训练不稳定。可以通过设置一个阈值，并确保任何超过这个阈值的梯度都被裁剪来实现。例如，在PyTorch中，你可以使用torch.nn.utils.clip_grad_norm_来裁剪梯度。
16. 为什么像ReLU或Leaky ReLU这样的非饱和激活函数有助于解决深度神经网络中的梯度消失问题？它们在RNN中有效吗？
    • 预期答案：像ReLU或Leaky ReLU这样的非饱和激活函数避免了像sigmoid或tanh函数那样出现的饱和问题，在饱和问题中梯度会变得太小。虽然ReLU在前馈网络中是有效的，但它可能会在RNN中导致神经元死亡，因此在RNN架构中通常更倾向于使用Leaky ReLU或其变体（如ELU）来保持一定的梯度流动。
17. RNN的记忆容量是什么意思？它与展开的循环层数或时间步长有什么关系？
    • 预期答案：RNN的记忆容量是指它在长序列中保留信息的能力。它受到展开的时间步数、隐藏状态大小和循环深度的影响。随着网络在更多的时间步上展开，理论上它可以保留更多的信息，但梯度消失问题可能会限制实际的容量。
18. 截断BPTT是如何工作的？为什么可能会使用它而不是标准的BPTT？
    • 预期答案：截断BPTT限制了梯度反向传播的时间步数。这降低了计算成本，并缓解了长序列的梯度消失问题。当序列对于标准BPTT来说太长而不切实际，或者当优先考虑训练效率时，会使用截断BPTT。
19. LSTM中的门是如何具体解决梯度消失问题，从而实现长期依赖关系学习的？
    • 预期答案：LSTM使用门控机制——特别是遗忘门、输入门和输出门——来控制信息的流动。LSTM中的细胞状态允许梯度在长序列中不变地流动，有助于防止梯度消失。遗忘门确保丢弃不相关的信息，而输入门确保保留有用的信息。
20. 就计算复杂性而言，GRU与LSTM相比如何？这两种架构之间的权衡是什么？
    • 预期答案：GRU比LSTM更简单，因为它们的门更少（两个对三个），并且没有单独的记忆单元，这导致参数更少，训练时间更快。然而，LSTM通过其额外的门（遗忘门）对信息的保留提供了更多的控制，这对于需要细粒度内存管理的更复杂任务可能是有益的。
21. 为什么在LSTM中通常将遗忘门的偏置初始化为一个较高的值？这对训练有什么影响？
    • 预期答案：将遗忘门的偏置初始化为一个较高的值（例如1或更高），可以鼓励模型在初始训练阶段保留更多的信息。这可以防止在开始决定忘记输入的某些部分之前过早地忘记相关信息，并帮助模型在学习长期依赖关系方面表现更好。
22. 为什么在资源受限的环境中GRU可能比LSTM更受青睐？这种选择对模型预测质量有什么影响？
    • 预期答案：由于门更少且结构更简单，GRU在计算上更高效。在资源受限的环境中，这会导致更快的训练速度和更低的内存消耗。虽然GRU在很多情况下与LSTM一样有效，但在更复杂的任务中，它们可能无法像LSTM那样有效地捕捉长期依赖关系，这可能会影响预测质量。
23. 双向RNN与标准RNN有何不同？在序列任务中什么时候会使用它？
    • 预期答案：双向RNN以正向和反向两个方向处理序列，使其能够捕捉来自过去和未来时间步的信息。这在需要整个序列上下文的任务中特别有用，例如在语言翻译或命名实体识别中。
24. 在RNN中使用Dropout与在前馈网络中使用Dropout有何不同？在将Dropout应用于循环层时应采取哪些预防措施？
    • 预期答案：在RNN中应用Dropout可能会很棘手，因为标准的Dropout会在每个时间步应用，这可能会破坏隐藏状态的时间连续性。相反，会使用循环Dropout，其中Dropout仅应用于层之间（而不是时间步之间），以在提供正则化的同时保持时间连贯性。
25. 为什么在RNN中正确的权重初始化很重要？为了避免梯度爆炸或梯度消失，初始化权重的最佳实践是什么？
    • 预期答案：正确的权重初始化对于确保RNN中稳定的梯度流动至关重要。应根据所使用的激活函数，使用Xavier初始化或He初始化等方法来初始化权重。不当的初始化会加剧梯度消失/梯度爆炸问题，导致训练效率低下。
26. 初始化隐藏状态如何影响RNN在训练期间的性能？为什么你可能会选择将状态初始化为零或其他学习到的值？
    • 预期答案：RNN中的隐藏状态通常初始化为零，但如果初始状态与最优轨迹相差很远，这可能会导致收敛速度缓慢。或者，学习到的初始状态或随机初始化可以为优化提供更好的起点。学习到的初始化通常会改善收敛情况，特别是在初始状态携带有意义信息的任务中。

6. 自主探究

1. 如果从神经网络中移除激活函数会发生什么？
2. 在构建神经网络时，对输入进行归一化处理有什么好处？
3. 损失函数和代价函数之间有什么区别？
4. 可以使用CNN进行文本处理吗？为什么不推荐使用CNN进行文本处理，而RNN更适合呢？
5. 我们可以使用RNN进行图像分类吗？证明你的答案。
6. 我们输入到RNN或LSTM中的输入的维度是多少？
7. 计算一个具有5个输入节点、1个包含3个隐藏节点的隐藏层的RNN中的参数数量。
8. 如果我们使用RNN来预测文本序列中的下一个字符，任何输出所需的维度是多少？
9. 为什么RNN可以基于文本序列中所有先前的标记来表达某个时间步的标记的条件概率？
10. 如果你通过一个长序列进行反向传播，梯度会发生什么变化？
11. 除了梯度裁剪之外，你能想到任何其他方法来应对循环神经网络中的梯度爆炸问题吗？
12. 比较在给定隐藏维度的情况下，GRU、LSTM和常规RNN的计算成本。特别注意训练和推理成本。
13. 由于候选记忆单元通过使用tanh函数确保值的范围在-1和1之间，为什么隐藏状态还需要再次使用tanh函数来确保输出值的范围在-1和1之间呢？
14. 如果你只实现GRU的一部分，例如，只实现一个重置门或只实现一个更新门，会发生什么？