时间序列模型（三）：GRU -- 轻量门控与效率权衡

本章要点

GRU 的更新门 $z_t$ 和重置门 $r_t$ 如何用更少的门、更少的状态实现 LSTM 级别的记忆能力。
为什么 GRU 比 LSTM 正好少 25% 参数，这在工程上意味着什么。
怎么读 GRU 的门激活，把它当作训练诊断工具。
一份实用的 GRU vs LSTM 决策矩阵，附参数、速度、预测质量的基准对比。
一份干净、生产级的 PyTorch 参考实现，包含真正影响稳定性的初始化与正则化技巧。

前置知识

第二篇 LSTM 中的三门机制。
基本 PyTorch（nn.Module、autograd、optimizer）。
知道 vanilla RNN 因为梯度反复经过 tanh 非线性而出现梯度消失。

GRU 单元结构：重置门、更新门，以及从 h_{t-1} 到 h_t 的 (1 - z) 梯度高速公路。

图 1. GRU 单元。两个门（r、z）+ 一个状态（h），替代 LSTM 的三个门 + 独立细胞状态。橙色的 (1 - z) ⊙ h_{t-1} 跳跃路径就是让长程依赖可学的线性梯度高速公路。

如果说 LSTM 是一个"三个阀门精细控制"的记忆系统，那 GRU 就是它的轻量化版本：同样的加性记忆账本，用两个门和单一隐藏状态实现。结果是参数少约四分之一、训练快 10–15%，并且在很大一类时间序列任务上，预测精度与 LSTM 统计意义上没有差别。

本文从头到尾走一遍 GRU：

定义 GRU 单元的四个公式，以及每一步的直觉。
为什么更新门 $z_t$ 创造的梯度高速公路解决了梯度消失。
在参数、训练速度、预测精度上的实证对比。
一份决策框架，省掉每个项目都做 A/B 测试的麻烦。

1. 用四个公式定义 GRU 单元

记输入 $x_t \in \mathbb{R}^{d_{in}}$、上一隐藏状态 $h_{t-1} \in \mathbb{R}^{h}$。GRU 用四步计算 $h_t$。

(1) 更新门 – “过去要保留多少？”

$$ z_t = \sigma\!\left(W_z\,[h_{t-1},\, x_t] + b_z\right) $$

sigmoid 输出在 $[0,1]$。$z_t \to 0$ 表示冻结（保留 $h_{t-1}$）；$z_t \to 1$ 表示完全刷新。

(2) 重置门 – “构造候选状态时让多少历史进来？”

$$ r_t = \sigma\!\left(W_r\,[h_{t-1},\, x_t] + b_r\right) $$

注意：重置门作用在候选的输入上，不参与最终的混合。$r_t \to 0$ 等价于"提议 $\tilde h_t$ 时无视历史"。

(3) 候选隐藏状态 – 用重置后的历史 + 当前输入提出一个新方案：

$$ \tilde h_t = \tanh\!\left(W_h\,[\,r_t \odot h_{t-1},\; x_t\,] + b_h\right) $$

逐元素乘积 $r_t \odot h_{t-1}$ 是重置门唯一出现的位置。

(4) 线性插值 – 输出是"旧"和"新"的凸组合：

$$ h_t = (1 - z_t)\odot h_{t-1} \;+\; z_t \odot \tilde h_t $$

这个公式是 GRU 的灵魂。它对 $h_{t-1}$ 是线性的，所以梯度 $\partial h_t / \partial h_{t-1}$ 含有一项 $(1 - z_t)$ – 一条不经过任何非线性的、加性的、直达通路。这就是图 1 里的梯度高速公路。

为什么这能解决梯度消失

vanilla RNN 写作 $h_t = \tanh(W h_{t-1} + U x_t)$，于是

$$ \frac{\partial h_t}{\partial h_{t-1}} = \operatorname{diag}\!\left(1 - \tanh^2(\cdot)\right) W. $$

跨 $T$ 步连乘，被 $\|\,W\,\|^T$ 乘上一个小导数，指数衰减。GRU 则有

$$ \frac{\partial h_t}{\partial h_{t-1}} = \operatorname{diag}(1 - z_t) \;+\; (\text{经 } \tilde h_t \text{ 的非线性项}). $$

只要模型想要记住（学到 $z_t \approx 0$），雅可比矩阵就近似单位阵，梯度可以无衰减地回传几百步。

2. GRU 为什么更轻：参数清算

一层 GRU 有三个权重矩阵（$W_z$、$W_r$、$W_h$），每个形状 $h \times (d_{in} + h)$，加偏置。LSTM 有四个（遗忘、输入、候选、输出）。计数：

$$ P_{\text{GRU}} = 3\,(d_{in} \cdot h + h^2 + 2h),\qquad P_{\text{LSTM}} = 4\,(d_{in} \cdot h + h^2 + 2h). $$

所以 $P_{\text{GRU}} = \tfrac{3}{4}\,P_{\text{LSTM}}$ – 正好少 25%，与宽度无关。

GRU 与 LSTM 在 hidden size 32 到 512 下的参数对比。

图 2. 25% 的差距是结构性的，不是经验性的：GRU 有三块权重，LSTM 有四块。hidden size 256 时 GRU 节省约 7 万参数；512 时节省约 27 万。在嵌入式推理场景下，这往往直接决定模型能不能塞进去。

下游影响：

训练速度：每个 epoch 大约省 10–15% 墙钟时间（§4 实测）。
显存：反向传播时激活和梯度更小 – 当序列长度逼着你减小 batch size 时尤其重要。
正则化：参数少 → 方差小，对小数据集尤其友好。

3. 隐藏状态长什么样

公式只有看到才让人放心。图 3 用一个 16 维 GRU 处理一个复合信号：慢振荡 + $t=27$ 附近的噪声爆发 + $t=45$ 的阶跃。

图 3. 不同单元各司其职、各占不同时间尺度。第 3、5、12 行像慢积分器 – 颜色随趋势缓慢漂移；第 8、11、15 行在 $t=45$ 阶跃前后翻转符号，是变化检测器。$t=27$ 的噪声爆发只震动高频单元；慢行被 $z_t \approx 0$ 保护下来。

这就是门控的实际收益：网络自己学到一组多时间尺度的基，根本不用你手动指定。

4. 预测质量：GRU 真的比 LSTM 差吗？

Chung 等（2014）和 Jozefowicz 等（2015）的核心结论 – 反复被复现 – 是：在大多数序列任务上，GRU 与 LSTM 没有统计意义上的差别。图 4 在一个合成但贴近实际的"季节 + 趋势"信号上把这一点画清楚。

图 4. 两种结构都能紧贴测试段。两者 RMSE 差距小于 0.02（信号幅度为 1） – 完全在随机初始化的噪声范围内。

LSTM 真正占优通常是三种情况之一：序列非常长（>200 步）时显式的 $c_t$ 帮助保留具体事实；数据集很大（>5 万条）时多出来的参数能被吸收；任务（翻译、摘要）天然受益于"记什么"和"输出什么"的解耦。

训练速度

图 5. 这个比例非常稳定：GRU 在两个数量级的序列长度上都能省约 12% 墙钟时间。右图说明这不是某个配置的偶然 – 它是少做一组门计算的直接结果。

做原型或超参数搜索时这 12% 复利效应明显：一个一周的 LSTM 调参变成六天，省下一天做分析。

5. 读懂门：把 GRU 当诊断工具用

任何门控 RNN 最被低估的特性是：门激活本身就是可解释的信号，可以画出来。图 6 展示了一个 GRU 在处理"$t=40$ 处发生 regime 切换、$t \in [68, 72]$ 出现瞬态尖峰"的信号时，平均 reset 门和 update 门的轨迹。

三联图：输入信号、最具响应性的 reset 门单元、最具响应性的 update 门单元，跨 100 个时间步。

图 6. 两个门在 $t=40$ regime 切换后都饱和到 0 附近。$z_t$ 接近 0 是在告诉单元"别更新了，新水平就是关键" – 单元被冻结在抬升后的基线上。$r_t$ 接近 0 是在告诉单元"构造候选时无视旧隐藏状态" – 这让模型迅速忘掉切换前的振荡。$t \in [68, 72]$ 的尖峰处，饱和进一步加深，模型更坚决地无视历史。

两个实际用途：

调试训练停滞：如果 $z_t$ 从第一个 epoch 起处处接近 0，模型已经冻结 – 通常是更新门偏置初始化得不好。把 $b_z$ 初始化为 $-1$ 鼓励早期保守，或者 $+1$ 鼓励第一步就刷新。
生产环境检测分布漂移：很多单元的 $r_t$ 突然下降，是模型在说"过去不再有信息量"的领先指标。这是个非常有用的协变量漂移信号。

6. PyTorch 参考实现

干净、可生产的 GRU 预测器。注意显式的权重初始化 – 对递归矩阵用正交初始化是对稳定性影响最大的一招。

 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
import torch
import torch.nn as nn

class GRUForecaster(nn.Module):
    def __init__(self, input_size, hidden_size, output_size,
                 num_layers=2, dropout=0.2):
        super().__init__()
        self.gru = nn.GRU(
            input_size=input_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
            dropout=dropout if num_layers > 1 else 0.0,
            batch_first=True,
        )
        self.head = nn.Sequential(
            nn.LayerNorm(hidden_size),
            nn.Dropout(dropout),
            nn.Linear(hidden_size, output_size),
        )
        self._init_weights()

    def _init_weights(self):
        for name, p in self.gru.named_parameters():
            if "weight_ih" in name:
                nn.init.xavier_uniform_(p)
            elif "weight_hh" in name:
                nn.init.orthogonal_(p)            # 稳定性的关键
            elif "bias" in name:
                nn.init.zeros_(p)
                # 鼓励初始倾向于"记忆"：更新门偏置 -> -1
                # PyTorch GRU 偏置布局：[r_bias | z_bias | n_bias]
                h = p.size(0) // 3
                p.data[h:2 * h].fill_(-1.0)

    def forward(self, x):                          # x: (B, T, d_in)
        out, _ = self.gru(x)
        return self.head(out[:, -1, :])            # 取最后一步预测

训练循环：四个稳定性必备

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import torch.nn.functional as F

def train_one_epoch(model, loader, opt, max_grad_norm=1.0, device="cuda"):
    model.train()
    losses = []
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        opt.zero_grad()
        pred = model(x)
        loss = F.mse_loss(pred, y)
        loss.backward()
        # 1. 梯度裁剪 -- 任何 RNN 都不能省
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)
        opt.step()
        losses.append(loss.item())
    return sum(losses) / len(losses)

四个必备：

梯度裁剪（max_norm=1.0）– 抓住偶发的梯度爆炸。
weight_hh 正交初始化 – 让初始时谱半径接近 1。
head 中的 LayerNorm – 把回归量纲与 GRU 激活解耦。
层间 dropout（PyTorch 只在堆叠的 GRU 层之间生效，不跨时间步 – 这是有意为之，不要随手加 per-step dropout）。

7. GRU vs LSTM：决策矩阵

没有普适的赢家。把图 7 当 checklist 用；如果你的需求大多数落在蓝色一栏，从 GRU 开始。

图 7. 我自己实际用的启发式就是底部那一行：先 GRU；只有当验证 RMSE 触底而你还有数据和算力余量时，才升级到 LSTM。

维度	GRU	LSTM
门数量	2（`r`、`z`）	3（`f`、`i`、`o`）
状态变量	1（`h`）	2（`h`、`c`）
同 hidden size 下参数	-25%	基线
训练墙钟	快约 12%	基线
序列长度甜区	20–150	100–1000+
数据规模甜区	< 5 万	> 1 万
可解释性	更易（门更少）	更难
常见失败模式	难任务上欠容量	小数据上过拟合

选择无所谓的情况

约一半的良构预测问题里，两种结构落在彼此的噪声范围内。这种情况下，用 GRU – 多出来的迭代速度是免费的生产力。除非你测出了切换的理由，否则别动。

8. 几个值得知道的变体

双向 GRU。拼接前向和后向两遍；参数翻倍，并且让你失去因果预测的能力（推理时不能使用未来数据）。适合 NER 这类序列标注任务。

1
2
3
self.bigru = nn.GRU(input_size, hidden_size, num_layers,
                    batch_first=True, bidirectional=True)
self.head  = nn.Linear(hidden_size * 2, output_size)

对 GRU 输出做注意力。把"用最后一个隐藏状态"的 head 换成对所有时间步加权求和。常常带来 1–3% 的 RMSE 改善，代价是一层线性：

1
2
3
4
5
6
7
class AttnHead(nn.Module):
    def __init__(self, hidden):
        super().__init__()
        self.score = nn.Linear(hidden, 1)
    def forward(self, h_seq):                       # (B, T, H)
        w = torch.softmax(self.score(h_seq), dim=1)  # (B, T, 1)
        return (w * h_seq).sum(dim=1)                # (B, H)

Conv1D + GRU 堆叠。在 GRU 前用 1D 卷积做特征抽取。卷积抽取局部 motif，GRU 在时间上整合。传感器数据的主力组合，常常比简单堆深 GRU 更好。

9. 常见坑与解法

几百步后 loss 爆炸。把学习率降到 1e-4；确认梯度裁剪是在 optimizer.step() 之前调用的；检查输入归一化。如果输入已经单位方差但梯度还爆，多半是递归权重没做正交初始化。

loss 下降后高位停滞。通常是欠容量。先把 hidden_size 翻倍或堆到 2 层，再考虑花哨变体。如果还不行，这就是切到 LSTM 的信号。

验证损失早早偏离训练损失。典型的小数据过拟合。把 dropout 拉到 0.4，加 weight decay（weight_decay=1e-5），用早停（patience=10）缩短训练。

变长序列。用 pack_padded_sequence / pad_packed_sequence。这不是性能优化 – 是正确性：不打包的话 GRU 会跑过 padding，最后一个时间步的输出毫无意义。

1
2
3
4
5
6
7
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence

packed = pack_padded_sequence(x, lengths.cpu(),
                              batch_first=True, enforce_sorted=False)
out, _ = gru(packed)
out, _ = pad_packed_sequence(out, batch_first=True)
last = out[torch.arange(out.size(0)), lengths - 1]   # 真·最后一步

总结

GRU 是大多数"非显然困难"序列建模问题的合理默认选择。它把 LSTM 砍掉一个门、一个状态，保留了线性插值 $h_t = (1 - z_t)\odot h_{t-1} + z_t \odot \tilde h_t$ 提供的梯度高速公路，并通过训练速度和参数效率赚回成本。

四个值得记住的数：

2 个门、1 个状态。
参数比 LSTM 少 25%。
训练墙钟快 12%。
在大多数中短序列任务上没有可测量的精度损失。

先用 GRU。测出理由再升级到 LSTM。

参考资料

Cho et al., Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation, EMNLP 2014.（GRU 原始论文）
Chung et al., Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling, NIPS Workshop 2014.
Jozefowicz, Zaremba, Sutskever, An Empirical Exploration of Recurrent Network Architectures, ICML 2015.
Greff et al., LSTM: A Search Space Odyssey, IEEE TNNLS 2017.