レム・咲く夜

LemuSakuya的个人博客网站堂堂登场

这一天终于来到了！！经过长期的策划以及愚蠢的大创项目策划书的拖延，我终于部署好了我的个人博客，真的很感谢Mizuki，用这么好的模版让我舒爽一整天！！！

標籤

レム・咲く夜

LemuSakuya的个人博客网站堂堂登场

这一天终于来到了！！经过长期的策划以及愚蠢的大创项目策划书的拖延，我终于部署好了我的个人博客，真的很感谢Mizuki，用这么好的模版让我舒爽一整天！！！

標籤

レム・咲く夜

LemuSakuya的个人博客网站堂堂登场

这一天终于来到了！！经过长期的策划以及愚蠢的大创项目策划书的拖延，我终于部署好了我的个人博客，真的很感谢Mizuki，用这么好的模版让我舒爽一整天！！！

標籤

🌸 咲夜の秘密メロディ

分類

站點統計

文章

79

分類

16

標籤

24

總字數

394,971

運行天數

0 天

最後活動

0 天前

4251 字

11 分鐘

序列模型 RNN LSTM GRU 注意力入门

2026-06-03

Neural Networks

Study Notes

/

Neural Networks

第 7 章序列模型、RNN、LSTM、GRU 与注意力入门#

7.1 学习目标#

理解序列数据的建模方式与静态表格数据的区别。
掌握 RNN 的基本思想、展开方式和训练难点。
理解 LSTM 与 GRU 如何缓解长依赖和梯度问题。
认识注意力机制的基本作用，并理解它为什么能提升序列建模能力。
能完成一个简单的文本分类或时间序列实验。

能力矩阵：

能力域	入门	进阶	熟练
序列理解	知道顺序信息	理解隐藏状态	能比较 RNN / LSTM / GRU
注意力	知道会“关注”	理解权重分配	能写简化注意力模块
任务实践	能做文本分类	能做时序预测	能分析长依赖问题

7.2 序列数据是什么#

序列数据的关键特征是“顺序重要”。例如：

句子中的词序
语音帧序列
时间序列传感器数据
视频帧序列

与图像不同，序列任务需要模型记住过去的信息。

7.3 RNN#

7.3.1 基本思想#

RNN 的核心是让隐藏状态在时间步之间传递：

h_t = \phi(W_x x_t + W_h h_{t-1} + b)

7.3.2 直觉#

当前时刻的输出不仅看当前输入，还看历史记忆；
隐藏状态相当于压缩后的“上下文摘要”。

7.3.3 展开#

RNN 可以沿时间展开成一条很长的计算图，因此训练时会遇到长链式求导问题。

7.4 RNN 的问题#

7.4.1 长期依赖难学#

当序列很长时，梯度在多次相乘后容易消失或爆炸。

7.4.2 信息瓶颈#

隐藏状态维度固定，长序列中的信息会被不断压缩，部分细节可能丢失。

7.5 LSTM#

7.5.1 核心思想#

LSTM 通过门控机制控制信息的写入、保留和输出。

7.5.2 三个门#

输入门：决定写入多少新信息
遗忘门：决定保留多少旧记忆
输出门：决定输出多少当前状态

7.5.3 优势#

LSTM 更适合长序列和长依赖任务，因为它有更好的记忆通道。

7.6 GRU#

7.6.1 核心思想#

GRU 是比 LSTM 更简洁的门控循环单元。

7.6.2 优势#

参数更少
训练更快
在一些任务上效果接近 LSTM

7.6.3 适用场景#

当数据量不大或工程上需要较轻结构时，GRU 常是不错的选择。

7.7 注意力机制入门#

7.7.1 为什么需要注意力#

单个固定长度隐藏状态很难承载全部历史信息，注意力机制允许模型在不同位置之间动态分配权重。

7.7.2 直觉#

模型不必平均看待每个词，而是可以“更关注”对当前任务更重要的部分。

7.7.3 简化公式#

\alpha_i = \text{softmax}(score(q, k_i))

\text{context} = \sum_i \alpha_i v_i

其中：

$q$ 是查询
$k_i$ 是键
$v_i$ 是值
$\alpha_i$ 是注意力权重

7.8 Attention 与 Transformer 的关系#

注意力机制本身不是 Transformer，但 Transformer 的核心就是多头自注意力。你可以先把注意力理解成“动态加权汇聚”，再逐步进入 Transformer。

7.9 常见序列任务#

情感分析
文本分类
机器翻译
语音识别
时间序列预测
异常检测

7.10 PyTorch 示例轮廓#

1
import torch
2
import torch.nn as nn
3

4
class TextRNN(nn.Module):
5
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
6
        super().__init__()
7
        self.embedding = nn.Embedding(vocab_size, embed_dim)
8
        self.rnn = nn.GRU(embed_dim, hidden_dim, batch_first=True)
9
        self.classifier = nn.Linear(hidden_dim, num_classes)
10

11
    def forward(self, x):
12
        x = self.embedding(x)
13
        out, h = self.rnn(x)
14
        return self.classifier(h[-1])

7.11 训练注意事项#

序列长度要统一处理：padding、mask。
长文本可能需要截断。
词表太大时要考虑 embedding 维度。
训练时要特别关注梯度稳定性。
如果序列太长，可以考虑注意力、卷积或 Transformer。

7.12 常见误区#

以为 RNN 一定比 MLP 更强。实际上取决于任务结构。
以为长序列只要堆更多层就行。实际上可能更难训练。
以为 LSTM 和 GRU 只是名字不同。实际上门控结构不同。
以为注意力只是“加权平均”。实际上它是可学习的对齐机制。

7.13 本章小结#

序列模型的关键是如何表达“顺序”和“记忆”。RNN 给出了基础框架，LSTM / GRU 解决了训练困难，而注意力机制进一步提升了模型对重要信息的选择能力。

7.14 课后练习#

写出 RNN 的隐藏状态递推公式并解释各项含义。
说明为什么 RNN 容易出现梯度消失。
比较 LSTM 和 GRU 的区别。
用自己的话解释注意力机制在做什么。
选一个文本分类任务，设计一个简单的 RNN 实验。

7.15 反向传播通过时间（BPTT）详解#

RNN 的训练通常使用反向传播通过时间（Backpropagation Through Time, BPTT）。把 RNN 在时间维度展开后，BPTT 相当于对这个展开的计算图进行常规反向传播。

假设单层 RNN 的递推为：

h_t = \phi(W_x x_t + W_h h_{t-1} + b)

损失关于参数 $W_h$ 的梯度可以写为时间步求和：

\frac{\partial L}{\partial W_h} = \sum_{t=1}^T \delta_t h_{t-1}^T

其中 $\delta_t$ 表示时间步 $t$ 的上游误差对线性变换输出的梯度，满足递归关系：

\delta_t = (W_h^T \delta_{t+1}) \odot \phi'(z_t) + \frac{\partial L_t}{\partial z_t}

因此梯度通过时间逐步传回，若 $\|W_h\|$ 小于 1，多次乘积会导致梯度消失；若大于 1，会导致梯度爆炸。

实践要点：

在训练 RNN 时启用梯度裁剪；
使用门控单元（LSTM/GRU）缓解长期依赖问题；
对长序列使用截断 BPTT（truncated BPTT）以降低计算成本。

7.16 LSTM 详细推导与门控解析#

一个标准 LSTM 单元的计算（按时间步 t）为：

i_t = \sigma(W_{xi} x_t + W_{hi} h_{t-1} + b_i)\\ f_t = \sigma(W_{xf} x_t + W_{hf} h_{t-1} + b_f)\\ o_t = \sigma(W_{xo} x_t + W_{ho} h_{t-1} + b_o)\\ ilde{c}_t = \tanh(W_{xg} x_t + W_{hg} h_{t-1} + b_g)\\ c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t\\ h_t = o_t \odot \tanh(c_t)

解释：

遗忘门 $f_t$ 决定保留多少先前记忆 $c_{t-1}$ ；
输入门 $i_t$ 决定当前候选信息 $\tilde{c}_t$ 写进细胞状态的多少；
输出门 $o_t$ 决定从细胞状态输出多少作为隐藏状态；
细胞状态 $c_t$ 提供了更直接的梯度流动路径，从而缓解消失梯度。

反向传播中需要对每个门的梯度做链式法则展开，工程实现中要注意中间量的缓存（ $i_t, f_t, o_t, \tilde{c}_t, c_t$ ）。

7.17 GRU 的数学形式与比较#

GRU 的更新较为简洁，常见形式为：

z_t = \sigma(W_{xz} x_t + W_{hz} h_{t-1})\\ r_t = \sigma(W_{xr} x_t + W_{hr} h_{t-1})\\ ilde{h}_t = \tanh(W_{xh} x_t + W_{hh} (r_t \odot h_{t-1}))\\ h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t

其中 $z_t$ 是更新门， $r_t$ 是重置门。GRU 把 LSTM 的某些门合并，参数更少且结构更简单。

实用对比：

LSTM 在某些语言建模任务上表现更好；
GRU 更轻量、训练更快；
两者的实际差距取决于任务与超参设置。

7.18 位置编码与 Transformer 简介#

Transformer 使用自注意力替代循环结构，关键在于它能并行计算并直接建模全序列的任意位置之间的依赖。

基本自注意力（Scaled Dot-Product Attention）定义为：

ext{Attention}(Q,K,V)=\text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V

Transformer 的核心组件：

多头注意力（Multi-Head Attention）：并行多个注意力头以捕捉不同子空间的依赖；
前馈网络（位置无关的逐位置 MLP）；
残差连接与 LayerNorm 保证训练稳定。

位置编码用于把序列的位置信息注入 Transformer，常见的正弦/余弦位置编码为：

PE_{(pos,2i)} = \sin(pos/10000^{2i/d_{model}})\\ PE_{(pos,2i+1)} = \cos(pos/10000^{2i/d_{model}})

7.19 多头注意力的实现要点#

设输入 $X\in\mathbb{R}^{T\times d_{model}}$ ，多头注意力将其映射为多个头：

Q = XW^Q,\quad K = XW^K,\quad V = XW^V

将 $Q,K,V$ 划分为 $h$ 个头，每个头维度为 $d_k=d_{model}/h$ ，并并行计算注意力，最后拼接并线性投影回 $d_{model}$ 。

实现细节：

注意数值稳定性（缩放因子 $\sqrt{d_k}$ ）；
掩码（mask）用于解码器的自回归任务以防止“看到未来”；
多头并行计算要注意维度变换的实现效率。

7.20 Transformer 的训练建议#

学习率调度：常用带 warmup 的学习率调度（例如 Adam + 线性 warmup + 反向平方根衰减）。
批量大小：Transformer 常受益于更大的 batch（并行化优势）。
标签平滑能提高泛化性和训练稳定性。
对于生成任务，使用 beam search 做推理而非贪心策略可提升质量。

7.21 序列学习的工程实践要点#

统一序列长度：padding 和 mask 的正确使用至关重要。
字典与 OOV 处理：词表、子词（BPE/WordPiece）或字符级模型。
Embedding 初始化：可以用预训练 embedding（GloVe, FastText）或随机初始化。
Batch 的构建：对可变长序列使用按长度排序+打包（pack_padded_sequence）以提升效率。
训练时监控 perplexity（语言模型）或 F1/AUC（分类）等更适合任务的指标。

7.22 实战代码：简化的多头注意力（PyTorch）#

1
import torch
2
import torch.nn as nn
3

4
class MultiHeadAttention(nn.Module):
5
    def __init__(self, d_model, num_heads):
6
        super().__init__()
7
        assert d_model % num_heads == 0
8
        self.d_k = d_model // num_heads
9
        self.h = num_heads
10
        self.wq = nn.Linear(d_model, d_model)
11
        self.wk = nn.Linear(d_model, d_model)
12
        self.wv = nn.Linear(d_model, d_model)
13
        self.fc = nn.Linear(d_model, d_model)
14

15
    def forward(self, x, mask=None):
16
        N, T, D = x.size()
17
        Q = self.wq(x).view(N, T, self.h, self.d_k).transpose(1,2)
18
        K = self.wk(x).view(N, T, self.h, self.d_k).transpose(1,2)
19
        V = self.wv(x).view(N, T, self.h, self.d_k).transpose(1,2)
20

21
        scores = (Q @ K.transpose(-2,-1)) / (self.d_k ** 0.5)
22
        if mask is not None:
23
            scores = scores.masked_fill(mask==0, -1e9)
24
        attn = torch.softmax(scores, dim=-1)
25
        out = (attn @ V).transpose(1,2).contiguous().view(N,T,D)
26
        return self.fc(out)