RNN循环结构如何处理变长序列

可视化演示

序列数据：有“先后”的世界

想象你正在读一本小说。你不可能同时看见第 1 页和第 100 页的内容，必须一页一页翻；而且第 100 页的剧情之所以精彩，恰恰因为你记住了第 1 页埋下的伏笔。文本、语音、股价、视频帧，这些数据天然带着“先后顺序”，统称为序列数据。与之相对，一张照片的所有像素是同时呈现的——图像模型可以“一眼看全”，但面对序列数据，模型必须学会“逐页阅读并记住前面讲了什么”。

用数学语言描述，一条序列就是一组按时间步排列的向量：第 t 个字（或第 t 秒的语音帧）用一个 d 维向量 \(x_t\) 表示，整条序列就是 \(x_1, x_2, \ldots, x_T\)。这里 \(T\) 是序列长度。注意一个重要事实：\(T\) 不固定——今天的新闻可能有 500 字，明天的可能只有 30 字。这种“长度可变”的特点，给深度学习模型的批量训练出了道难题：矩阵运算要求形状整齐，长短不一的序列怎么塞进同一个批次？

为了处理这类数据，RNN 引入了“隐状态” \(h_t\) 的概念：它是一个不断被更新的向量，记录“从序列开头到当前时刻”的浓缩信息。每读入一个新的 \(x_t\)，RNN 就结合上一时刻的 \(h_{t-1}\)，计算新的 \(h_t\)。输入顺序一旦颠倒，\(h_t\) 的内容就完全不同，输出也跟着变——这正是 RNN 能捕捉顺序信息的根本原因。

回到小说的比喻：RNN 就是你读书时的“工作记忆”。它逐页翻看，每翻一页就把前面的剧情与当前页的内容整合进脑海里。你不会忘记开头出场的人物，因为记忆已经随着翻页一路传递下来——这就是 RNN 的起点。

循环单元：接力棒运动员

现在把“读书”换成“接力赛”。每位接力运动员的职责是：接过上一棒递来的接力棒（旧记忆 \(h_{t-1}\)），看看当前跑道边的风景（新输入 \(x_t\)），在脑中迅速整理——“旧的哪些还要保留？新的哪些要记下来？”——然后带着更新后的记忆（新隐状态 \(h_t\)）跑向下一棒。任何一棒手里拿着的记忆，都是“从起点到这里整段路程的浓缩”。

这个“接棒—融合—记忆”的动作，对应 RNN 单元里一个关键公式。它把上一隐状态 \(h_{t-1}\) 与当前输入 \(x_t\) 分别乘上各自的权重矩阵，相加后经过非线性激活函数压缩，得到新隐状态 \(h_t\)。

权重矩阵 \(W_{hh}\) 决定“上一记忆的影响力度”，\(W_{xh}\) 决定“当前输入的影响力度”，偏置 \(b_h\) 是运动员的“个人习惯”。tanh 激活函数把结果压到 \((-1, 1)\)，防止记忆无限膨胀——就像运动员给自己打气时也要保持冷静，情绪值不能失控。

所以，一位接力运动员更新记忆的方式就是“旧记忆 × 重视程度 + 新画面 × 关注程度 + 个人习惯”，再压一压情绪。这套动作对所有接力手完全一致——这正是“权重共享”的含义。

前向传播：逐棒传递

比赛开始了。第 1 棒起跑时手里没有接力棒——对应初始隐状态 \(h_0\) 通常设为全零向量。每一棒拿到接力棒后，除了更新记忆，还会举起一块“信息牌”（输出 \(y_t\)），让观众看到目前比赛进行到哪一步。所有运动员遵循同一本规则手册（同一套权重），跑完整个赛道，观众就看到了一串完整的信息牌序列。

在 RNN 中，“举牌”就是计算输出：得到隐状态 \(h_t\) 后，通过权重矩阵 \(W_{hy}\) 把它映射到输出空间（比如词典大小），再用 softmax 变成概率分布，表示“下一个词是词典中每个词的概率”。

关键点在于权重共享——不管序列多长，\(W_{hh}\)、\(W_{xh}\)、\(W_{hy}\) 在所有时间步复用。对比全连接网络，参数数量不会随输入长度增长，这让 RNN 面对超长句子不会参数爆炸。

整个前向传播就像一场接力赛的全程录像：从第 1 棒到第 \(T\) 棒，每位选手都按同一本规则手册接棒、更新记忆、举牌。观众最终看到的是每个时刻的“信息牌”。

变长输入：不同长度的赛道

现在问题来了：一场训练中有三条赛道，长度分别是 100 米、50 米、200 米，裁判怎么同时发令？最笨的办法是“强行拉齐”——给短赛道补建“虚拟跑道”，让它看起来也是 200 米。补出来的路段没有真实选手，只有假人立在那里；裁判计成绩时忽略假人路段。补建虚拟路段的过程叫 padding，裁判忽略假人路段的做法叫 masking。

训练时，GPU 喜欢“方方正正”的矩阵。如果一批里有长句有短句，直接塞进模型会报错。所以常见做法是：找到这一批里最长的句子，把所有短句末尾补上特殊符号（通常是 0 或 [PAD]），让整批句子长度一致。masking 则是一个 0/1 掩码：真实位置是 1，padding 位置是 0。

如果不做 masking，模型会学到“句子末尾有个 [PAD] 符号”这种无意义规律，严重时把 padding 位置当成真实输出目标来优化。padding 在词嵌入后参与矩阵运算，所以“是否忽略它”必须由掩码显式告诉损失函数。

有了“虚拟跑道”和“裁判忽略”这两件法宝，长短不一的句子就能在同一条起跑线上公平竞赛。这也是工程中处理变长序列最核心、最常用的套路。

双向循环：双向接力赛

普通接力赛只从起点跑向终点，到了最后才知道全程发生了什么。但理解一句话往往需要“前后夹击”：句子“小明把李雷打了”——到底谁挨打，要看后半句才明白。如果能安排两支队伍同时起跑，A 队从左跑到右，B 队从右跑到左，两支队伍在中途相遇时交换记忆，那么每个位置都能同时拥有“前面的伏笔”和“后面的回响”。

这个想法就是双向 RNN（BiRNN）。它用两套独立的 RNN 参数处理同一个序列：前向 RNN 按 \(x_1 \to x_2 \to \cdots \to x_T\) 更新隐状态 \(\overrightarrow{h_t}\)；后向 RNN 按 \(x_T \to x_{T-1} \to \cdots \to x_1\) 更新隐状态 \(\overleftarrow{h_t}\)。每个时间步的最终隐状态是两者的拼接。

拼接操作 [;] 把两个向量首尾相连。假设前向隐状态 100 维、后向 100 维，拼接后就是 200 维，同时携带“过去”与“未来”的信息。后文涉及的 BiLSTM、Transformer 中的双向注意力，都是对“只看一遍”的改进。

双向接力赛让每位选手都拥有“左右脑”——左脑知道前面发生了什么，右脑知道后面将要发生什么。对于翻译、序列标注等需要全局理解的任务，双向 RNN 往往是标配。

梯度传播：成绩复盘难题

比赛结束，教练要复盘了。教练想搞清楚：“第 1 棒选手训练时有没有偷懒？”但问题来了——第 1 棒的影响要传过第 2、3、……、第 T 棒才能显现，而每一棒传达时都会“打一点折扣”。如果打了 50 棒折扣，第 1 棒的存在感早就消失了。这就是 RNN 著名的“梯度消失”：训练时，离当前时间步太远的记忆几乎得不到有效的梯度更新。

训练 RNN 使用反向传播，但因为 RNN 每个时间步共享权重，梯度需要沿时间步回溯——术语叫 BPTT（Backpropagation Through Time，时间反向传播）。在数学上，从第 T 步到第 1 步的梯度是一个非常长的连乘式。

连乘式中每一项 \(\partial h_t / \partial h_{t-1}\) 与 tanh 的导数有关：tanh 导数最大为 1，如果权重矩阵的谱范数又小于 1，连乘几十步后梯度趋向 0——梯度消失；反之如果权重矩阵特征值大于 1，连乘结果爆炸——梯度爆炸。工程上常用梯度裁剪防止爆炸，而梯度消失则激发了 LSTM、GRU 等“带传送带”改进结构的诞生。

教练复盘时发现：第 T 棒的错误很容易传给第 T-1、T-2 棒，但要追溯到第 1 棒，中间隔了太多“折扣关卡”。要解决它，要么加一条“直达通道”（如 LSTM 的记忆单元），要么换一种“短距离传播”的架构（如 Transformer）——这就是后文将要展开的伏笔。

AI 应用场景

Python 演示

import numpy as np def sigmoid(x):    return 1.0 / (1.0 + np.exp(-x)) def forward_rnn(X, W_hh, W_xh, b_h, W_hy, b_y):    """朴素 RNN 前向传播: 逐时间步更新隐状态并输出"""    d = W_hh.shape[0]    h = np.zeros(d)  # h0 初始化为全零向量    outputs = []    for t in range(len(X)):        h = np.tanh(W_hh @ h + W_xh @ X[t] + b_h)        y = sigmoid(W_hy @ h + b_y)        outputs.append(y)    return outputs, h def pad_and_mask(batch, max_len):    """把长度不一的序列补齐到 max_len, 返回填充张量与掩码"""    d = batch[0].shape[-1]    X_pad = np.zeros((len(batch), max_len, d))    mask = np.zeros((len(batch), max_len), dtype=np.float32)    for i, seq in enumerate(batch):        L = len(seq)        X_pad[i, :L] = seq        mask[i, :L] = 1.0    return X_pad, mask def masked_loss(outputs, targets, mask):    """只在真实位置(mask=1)上计算二元交叉熵损失"""    loss, total = 0.0, 0.0    for y, tag, m in zip(outputs, targets, mask):        if m == 1.0:            loss += -(tag * np.log(y + 1e-9) + (1 - tag) * np.log(1 - y + 1e-9))            total += 1.0    return loss / total if __name__ == "__main__":    np.random.seed(0)    d, hidden, out = 4, 8, 1    W_hh = np.random.randn(hidden, hidden) * 0.1    W_xh = np.random.randn(hidden, d) * 0.1    b_h = np.zeros(hidden)    W_hy = np.random.randn(out, hidden) * 0.1    b_y = np.zeros(out)     X1 = np.random.randn(3, d)  # 长度 3    X2 = np.random.randn(2, d)  # 长度 2     X_pad, mask = pad_and_mask([X1, X2], max_len=3)    print("pad 后 batch 形状:", X_pad.shape)    print("mask 矩阵:\n", mask)     outs1, h1 = forward_rnn(X1, W_hh, W_xh, b_h, W_hy, b_y)    outs2, h2 = forward_rnn(X2, W_hh, W_xh, b_h, W_hy, b_y)    print("样本1 输出数:", len(outs1), "最终隐状态:", h1.shape)    print("样本2 输出数:", len(outs2), "最终隐状态:", h2.shape)     targets = [1.0, 0.0, 1.0]  # 样本1 的三个真实标签    loss = masked_loss(outs1, targets, mask[0])    print("带 mask 的损失:", round(loss, 4))

1. h = np.zeros(d)初始隐状态置零，象征第一棒运动员手里没有接力棒。
2. h = np.tanh(W_hh @ h + W_xh @ X[t] + b_h)这是 RNN 核心更新公式：旧记忆与当前输入融合后压缩到 [-1, 1]。
3. X_pad = np.zeros((len(batch), max_len, d))padding 的实现：先开辟“最长长度”的全零张量，再把每个样本填进去。
4. mask[i, :L] = 1.0真实位置标记为 1，padding 位置保持 0，这就是 masking。
5. if m == 1.0:只在真实位置上累加损失，实现“裁判忽略虚拟路段”的效果。

常见误区

面试题