torch.nn.GRU 输入输出形状与维度组合完全解析

GRU 这个词在 PyTorch 圈子里出现的频率极高，但真正把torch.nn.GRU的输入输出形状、batch_first的语义、h_n和output的区别一次性讲透的资料并不多。我前后在几个文本分类和时序预测项目里用过它，也帮同事排查过不下几十次的维度报错，发现绝大多数问题都集中在同一个地方：输入输出的三维张量到底哪一维是什么，以及在多层、双向的情况下这些维度怎么组合。这篇就把torch.nn.GRU的输入输出彻底拆开讲一遍，从构造参数到前向传播，从最小可运行示例到变长序列的 padding 陷阱，再到实际项目里该怎么接下游网络。如果你刚开始接触循环神经网络，或者已经用过但每次写代码都要翻文档确认形状，这篇应该能让你以后少查几次 API。

1. torch.nn.GRU 到底在算什么：从门控逻辑到构造参数

很多人写nn.GRU的时候是把它当黑盒用的，输入丢进去，输出拿出来，形状对得上就行。但只要涉及调试，黑盒就会变成折磨。所以先把内部在算什么捋清楚，后面所有形状规则都能从这套逻辑里推导出来，不用死记。

1.1 门控结构决定了你要关心哪些形状

GRU 的核心是两个门加一个候选状态。重置门r_t决定上一时刻的隐藏状态有多少要参与候选状态的计算，更新门z_t决定新旧状态各占多少比例，候选状态n_t则是当前输入和历史信息的融合结果。用公式写出来是这样：

• r_t = sigmoid(W_ir @ x_t + b_ir + W_hr @ h_{t-1} + b_hr)
• z_t = sigmoid(W_iz @ x_t + b_iz + W_hz @ h_{t-1} + b_hz)
• n_t = tanh(W_in @ x_t + b_in + r_t * (W_hn @ h_{t-1} + b_hn))
• h_t = (1 - z_t) * n_t + z_t * h_{t-1}

从形状角度读这些公式，能得到几个关键结论。第一，输入x_t的最后一维必须等于input_size，隐藏状态h_t的最后一维必须等于hidden_size，这两者相互独立，你完全可以设计一个input_size=100、hidden_size=32的模型，把高维输入压到低维隐空间。第二，三个门的计算都要把x_t和h_{t-1}投影到hidden_size维度上再相加，所以 PyTorch 把三组权重在输出维度上拼接存储，这也是为什么你去打印weight_ih_l0会看到形状是(3 * hidden_size, input_size)，而不是三个独立的矩阵。

那3这个因子对应的是哪三个门，顺序是什么？这点官方文档写得比较隐蔽，实际是r、z、n的顺序，也就是重置门、更新门、候选状态。你在做手写对齐或者加载预训练权重时如果搞错了顺序，模型不会报错，但效果会莫名其妙地崩掉。我见过有人把权重导出来在 NumPy 里重写推理，结果精度差了一大截，排查半天就是这里的顺序反了。

注意：如果你打算把 PyTorch 训练好的权重导出到其他框架或者手写推理，务必确认门控顺序是重置门、更新门、候选状态，而不是按直觉猜的更新门在前。

再看参数量。单层单向的 GRU 一共有3 * hidden_size * (input_size + hidden_size) + 6 * hidden_size个参数，前面的3 * hidden_size * (input_size + hidden_size)是两组权重矩阵，后面的6 * hidden_size来自两个偏置项b_ih和b_hh，每个都是3 * hidden_size。这个公式在估算显存和模型大小时很有用。举个实际数字，input_size=300、hidden_size=128的单层 GRU，参数量是3 * 128 * (300 + 128) + 6 * 128 = 164352 + 768 = 165120，大概 16 万参数，比一层 512 维的全连接层（约 26 万）还小。所以 GRU 本身并不吃参数，真正吃资源的是它按时间步展开的计算量。

1.2 nn.GRU 构造参数逐项翻译

nn.GRU的构造函数签名里参数不多，但每一个都会影响输入输出的形状或者训练行为，逐个过一遍。

input_size就是每个时间步输入向量的维度。做词向量输入时，它等于词向量维度；做传感器时序时，它等于每个时刻的特征数量。注意它不等于词表大小，也不等于 batch size，这是新手最容易混淆的一点。hidden_size是隐状态维度，也是输出的最后一维的基础值，调大能提升表达能力但会线性增加计算量。

num_layers是堆叠层数，默认 1。层数大于 1 时，第 i 层的输出会作为第 i+1 层的输入，所以中间层不需要你手动指定维度，框架会自动处理。但要注意，多层时h_0的第一维会从1变成num_layers，这是形状报错的高发区。

bias默认True，关掉的话上面参数量公式里的6 * hidden_size就没了。实践中很少有人关，除非你在做极致的量化压缩。

batch_first默认是False，这是 PyTorch 循环神经网络家族的历史遗留设计，也是被吐槽最多的一个参数。它默认要求输入形状是(seq_len, batch, input_size)，也就是序列长度在前。现代的数据加载器习惯把 batch 放第一维，所以实际项目里基本上都会显式写batch_first=True。这个参数只影响输入x和输出output的前两维顺序，不影响h_0和h_n，后者永远是 batch 在第二维。

dropout只在num_layers > 1时生效，作用于层与层之间。如果你设置了num_layers=1却传了dropout=0.5，框架会给出警告并且忽略这个参数。我见过有人以为单层 GRU 也能靠这个参数做正则化，训练了半天没效果，就是这个原因。

bidirectional打开后，hidden_size的实际输出维度会翻倍，output的最后一维变成2 * hidden_size，h_n的第一维也会翻倍。这个后面单独展开说。

2. 输入张量的形状规则：为什么总是三维

GRU 的输入必须是三维张量，这个约束经常让从全连接网络转过来的人不适应。全连接层可以接受(batch, features)的二维输入，GRU 为什么不行？因为多出来的一维就是时间。

2.1 输入 x 的三个维度分别代表什么

batch_first=False（默认）时，x的形状是(seq_len, batch, input_size)。三个维度依次是时间步数、批大小、单步特征维度。batch_first=True时变成(batch, seq_len, input_size)，只是把前两维换了个位置，语义不变。

为什么默认把序列长度放前面？因为早期 PyTorch 的设计参考了 Torch7 和 cuDNN 的接口约定，cuDNN 底层更倾向于时间维在前，这样在按时间步循环时内存访问更连续。虽然现在的实现已经做了优化，但这个默认值一直保留下来了。实际写代码时我的习惯是统一用batch_first=True，理由是 DataLoader 出来的 batch 天然是第一维，如果再用默认值就得在 forward 里做两次transpose，代码里到处是.transpose(0, 1)很难维护，而且 transpose 返回的是视图，后续如果接view或者reshape很容易踩到内存不连续的坑。

举个具体例子。假设你在做一个基于传感器数据的动作识别任务，采集频率 50Hz，窗口长度 2 秒，每条样本就是 100 个时间步，每个时间步有 6 个特征（三轴加速度加三轴角速度）。batch size 取 32，那么batch_first=True时输入形状就是(32, 100, 6)，input_size=6。这三个数字分别对应什么，写代码时一定要在心里默念一遍，因为(100, 32, 6)和(32, 100, 6)在很多情况下都能跑通，不会报错，但语义完全错了，模型学不到任何东西。

关于输入维度还有一个容易忽略的点：input_size在模型定义时就固定了，运行时如果喂进来的特征维度对不上，会直接抛RuntimeError。这个错误信息通常长这样：Expected input of size (..., 6), got (..., 8)。看到这类报错先检查特征工程那一步是不是多加了几列，比如把时间戳或者 ID 也一起塞进去了。

2.2 batch_first 参数到底改了什么

这个参数的作用范围经常被误解。它只改两件事：输入x的前两维顺序，以及输出output的前两维顺序。它不改h_0的形状，也不改h_n的形状。这两个张量永远保持(num_layers * num_directions, batch, hidden_size)。

所以你会遇到这种组合：batch_first=True，输入是(32, 100, 6)，h_0却是(1, 32, 32)而不是(32, 1, 32)。新手看到这个组合会本能地觉得不一致，然后把h_0写成(32, 1, 32)，接着就会收到这样的报错：

RuntimeError: Expected hidden size (1, 32, 32), got (32, 1, 32)

这个报错信息其实很友好，直接把期望值和实际值都打出来了。遇到就按提示改，不用猜。

还有一种情况是h_0干脆不传。这时候框架会默认用全零初始化，等价于h_0 = torch.zeros(num_layers * num_directions, batch, hidden_size, device=x.device)。不传h_0在大部分任务里是合理的，因为零初始状态经过几个时间步就会被输入信息覆盖掉。但在一些对初始状态敏感的任务里（比如很短的序列），显式传一个可学习的初始状态可能会有帮助，这时候把h_0定义成nn.Parameter就可以了。

2.3 初始隐藏状态 h_0 的维度怎么定

h_0的形状公式是(num_layers * num_directions, batch, hidden_size)。这里的乘法是直接相乘，不是拼接。单向时num_directions=1，双向时是2。三层双向的话，第一维就是6。

这个第一维的内部排列顺序也值得记一下：按层排列，每层内部先正向后反向。也就是说num_layers=2、双向时，索引0是第 0 层正向，1是第 0 层反向，2是第 1 层正向，3是第 1 层反向。

如果你想让不同层用不同的初始状态，就按这个顺序去填充。如果所有层都用零，直接传None或者创建全零张量都行。我一般会在 forward 里写：

if h0 is None: h0 = torch.zeros(self.num_layers * self.num_directions, x.size(0), self.hidden_size, device=x.device, dtype=x.dtype)

注意这里的dtype=x.dtype，混合精度训练时这个细节很关键。如果忘了写，默认创建的h_0是float32，而x可能是float16，两者相加就会报 dtype 不匹配。这类错误在纯float32环境下不会出现，一上 AMP 就暴露了。

3. 输出到底是什么：output 与 h_n 的区别与联系

nn.GRU的前向传播返回一个元组，第一个是output，第二个是h_n。很多人搞不清这两个到底有什么区别，觉得反正都是隐藏状态，随便取一个用。实际上它们的语义差别很大，用错了会直接影响模型效果。

3.1 output 的每一帧从哪来

output包含了每个时间步的隐藏状态。batch_first=True时形状是(batch, seq_len, num_directions * hidden_size)。对于单向、单层的 GRU，output[:, t, :]就是第 t 个时间步的隐状态h_t。

这里有个细节：output只包含最后一层的输出。如果你堆了 3 层，output是第 3 层每个时间步的输出，第 0 层和第 1 层的中间结果你是拿不到的。这一点在做特征提取或者可视化时很重要，想要中间层的表示只能自己手动逐层调用，或者拆成多个单层 GRU 手动串联。

再说长度。output的seq_len维度和输入的seq_len完全一致，即使你传了h_0也一样。这意味着一件事：如果你做了 padding，output在 padding 位置也会有值。这些值是基于 padding 内容算出来的，语义上是无意义的，后面接下游网络时必须做 mask，否则 padding 的噪声会污染结果。这是我在实际项目里踩过的最深的坑之一，下面第 5 节会展开讲。

3.2 h_n 与 output[-1] 的等价性验证

这是最常被问到的一个问题：output[:, -1, :]和h_n[-1]是一回事吗？

在单向、单层的情况下，答案是完全相同，数值上一模一样。原因是h_n存的就是最后一个时间步的隐状态，而output[:, -1, :]也是最后一个时间步的输出，两者指向同一个东西。

在单向、多层的情况下，output[:, -1, :]仍然等于h_n[-1]。因为output本来就是最后一层的输出序列，h_n[-1]也是最后一层的最后时刻状态。

在多方向或者双向的时候就不同了。双向时output[:, -1, :]是[正向的最后一步, 反向的最后一步]，而反向分支的最后一步对应的其实是序列的第一个位置。同时h_n[-2:]里存的是[正向最后一步, 反向最后一步]，这里的反向最后一步对应的是输入序列的开头。所以output[:, -1, :]和h_n[-2:]虽然都是两个hidden_size的拼接，但反向那半段不是同一个东西。

可以用一段几行的代码验证这个等价关系，这也是我自己写完 GRU 之后的固定检查动作：

import torch import torch.nn as nn torch.manual_seed(42) gru = nn.GRU(input_size=5, hidden_size=6, num_layers=2, batch_first=True) x = torch.randn(4, 7, 5) out, hn = gru(x) # 单向多层：output 最后一帧等于 h_n 的最后一层 print(torch.allclose(out[:, -1, :], hn[-1], atol=1e-6)) # True

如果你把这个检查写进单元测试，以后重构网络结构时能第一时间发现行为变化。

3.3 单向/双向/多层组合下的形状对照

这张表是我自己整理的，贴在工位上一段时间，后来记住了才撕掉。基准设定是batch=4、seq_len=7、input_size=5、hidden_size=6、batch_first=True。

如果batch_first=False，把上面表格里 output 的前两维对调即可，h_n不变。这个规律记住之后，任何维度报错都能在脑子里快速定位。

还有一个常见的取用方式，做分类任务时从双向模型里提取句子表示。标准写法是把h_n拆成正向和反向两部分，然后拼接：

num_layers, batch, hidden = hn.shape[0] // 2, hn.shape[1], hn.shape[2] hn = hn.view(num_layers, 2, batch, hidden) forward_last = hn[-1, 0] # 正向最后一步 backward_last = hn[-1, 1] # 反向最后一步 sentence_vec = torch.cat([forward_last, backward_last], dim=1) # (batch, 2*hidden)

这段代码几乎是双向文本分类的标配，值得直接记住。注意hn.view的第一个参数是层数，不是num_layers * 2，这里写错的话张量元素总数对不上会立刻报错，所以还算安全。

4. 可直接复现的完整示例

前面讲的都是规则，这一节直接把代码贴出来，从构造到前向传播到结果验证，照着跑一遍就能把形状彻底搞明白。

4.1 最小可运行示例

import torch import torch.nn as nn torch.manual_seed(0) batch_size = 4 seq_len = 7 input_size = 5 hidden_size = 6 num_layers = 2 gru = nn.GRU( input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, ) # 输入：batch 在第一维 x = torch.randn(batch_size, seq_len, input_size) # 初始状态：层数在前，batch 在第二维 h0 = torch.zeros(num_layers, batch_size, hidden_size) out, hn = gru(x, h0) print("input :", x.shape) # torch.Size([4, 7, 5]) print("output:", out.shape) # torch.Size([4, 7, 6]) print("h_n :", hn.shape) # torch.Size([2, 4, 6]) # 验证最后一层的最后一帧 print(torch.allclose(out[:, -1, :], hn[-1], atol=1e-6)) # True

跑通之后可以试着把batch_first改成False，同时把x改成(7, 4, 5)，观察output的形状变化。这个对照实验做一次，以后就不会再混淆了。

4.2 手写单步 GRU 对齐官方实现

想要真正确定自己理解了门控顺序和公式，最好的办法是手写一个单步版本，跟官方实现对一遍数值。

import torch import torch.nn as nn torch.manual_seed(1) hidden_size, input_size = 6, 5 gru = nn.GRU(input_size, hidden_size, batch_first=True) w_ih = gru.weight_ih_l0 # (3*hidden, input) w_hh = gru.weight_hh_l0 # (3*hidden, hidden) b_ih = gru.bias_ih_l0 # (3*hidden,) b_hh = gru.bias_hh_l0 # (3*hidden,) def manual_step(x_t, h_prev): gi = x_t @ w_ih.T + b_ih gh = h_prev @ w_hh.T + b_hh i_r, i_z, i_n = gi.chunk(3, dim=-1) h_r, h_z, h_n = gh.chunk(3, dim=-1) r = torch.sigmoid(i_r + h_r) z = torch.sigmoid(i_z + h_z) n = torch.tanh(i_n + r * h_n) return (1 - z) * n + z * h_prev x = torch.randn(1, 3, input_size) out, _ = gru(x) h = torch.zeros(1, hidden_size) for t in range(x.size(1)): h = manual_step(x[:, t, :], h) print(torch.allclose(h, out[:, -1, :], atol=1e-6)) # True

这段代码有两个价值点。一是确认了chunk(3)出来的顺序是重置门、更新门、候选状态，二是确认了b_ih和b_hh是两个独立的偏置，不是共享的。如果你在做模型移植或者量化，这段代码可以直接当参考实现。

4.3 文本分类里的实际接法

光看形状示例还不够，实际项目里怎么把 GRU 接进一个完整的分类网络是更实际的问题。下面是一个可以直接改改就用的文本分类模型。

import torch import torch.nn as nn from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence class GRUClassifier(nn.Module): def __init__(self, vocab_size, emb_dim, hidden_size, num_classes, num_layers=1, dropout=0.3): super().__init__() self.emb = nn.Embedding(vocab_size, emb_dim, padding_idx=0) self.gru = nn.GRU( input_size=emb_dim, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, bidirectional=True, dropout=dropout if num_layers > 1 else 0.0, ) self.dropout = nn.Dropout(dropout) self.fc = nn.Linear(hidden_size * 2, num_classes) def forward(self, token_ids, lengths): emb = self.emb(token_ids) # (B, L, E) packed = pack_padded_sequence( emb, lengths.cpu(), batch_first=True, enforce_sorted=False ) out, hn = self.gru(packed) out, _ = pad_packed_sequence(out, batch_first=True) # (B, L, 2H) # 用 mask 做平均池化，避开 padding 位置 mask = (token_ids != 0).unsqueeze(-1).float() # (B, L, 1) summed = (out * mask).sum(dim=1) pooled = summed / mask.sum(dim=1).clamp(min=1e-9) return self.fc(self.dropout(pooled))

这里选择平均池化而不是取h_n，原因是平均池化对短文本更稳，尤其是当句子长度差异很大时，h_n会被最后一个有效词的信息过度主导。当然如果你的任务是判断整句的语义倾向，取h_n拼接也完全可行，把pooled那几行换成从hn里拆方向拼接即可。

padding_idx=0这个参数别漏。它让 embedding 层在反向传播时跳过 id 为 0 的位置，避免 padding 污染词向量。配合pack_padded_sequence，两个一起用才能把 padding 的影响压到最低。

5. 变长序列、padding 与那些容易被忽略的坑

真实数据里序列长度几乎不可能整齐划一，要么 padding，要么截断。这一节讲清楚 padding 到底会带来什么后果，以及怎么处理才干净。

5.1 右侧 padding 对 h_n 的污染

假设一个 batch 里有两条序列，长度分别是 3 和 5，padding 到 5。右边补两个零向量。如果不做任何处理直接喂给单向 GRU，会发生什么？

第一个样本的h_n是经过 5 个时间步算出来的，其中后两个时间步的输入是零向量。注意，输入是零不代表隐状态不变化。因为z_t和r_t都是sigmoid(W @ 0 + W @ h + b)，只要偏置不为零，门控值就不是固定值，h_t会继续演化。所以最终得到的h_n和真正读到第 3 个词就停下的结果是不一样的。

这个差异有多大？如果序列很长、padding 比例很小，影响可以忽略。但如果序列普遍很短而 padding 很多，或者偏置初始化得比较激进，h_n会明显偏移。我做过一个对比实验，在一个长度为 10 到 15 的短文本任务上，不做 pack 和做 pack 的准确率差了将近 2 个百分点，这对分类任务来说不算小。

5.2 pack_padded_sequence 的正确用法

pack_padded_sequence的作用就是把 padding 位置直接从计算中剔除，让 GRU 在每个 batch 内只处理有效的时间步。用法上有几个必须注意的点。

第一，lengths必须是 CPU 上的 int64 张量。如果你从 GPU 上的张量直接切出来，会报错。所以代码里要写.cpu()。第二，enforce_sorted=False建议显式写上。默认为True时要求一个 batch 内的序列按长度降序排列，很多人的数据加载器不做这个排序，就会收到Expected sorted相关的报错。设成False后框架内部会自动处理排序和还原，用起来省心。第三，pack 之后output的类型是PackedSequence，不能直接做索引或者切片，必须先pad_packed_sequence还原。还原之后output的序列长度等于这个 batch 内的最大长度，不是全局最大长度，如果后面要拼接或者做定长操作，可能还需要再 pad 一次。

第四，pad_packed_sequence返回的第二项是lengths，很多人用不上就忽略了。但如果你的下游逻辑依赖有效长度，这个值是有用的。

还有一个小细节：pack 之后h_n是准确的，不受 padding 影响。所以在只需要最后状态的任务里，其实可以 pack 之后直接取h_n，跳过还原那一步，能省一点显存和时间。

5.3 双向模型里 output 最后一帧不等于序列结尾

这是前面提过但值得单独强调的一点。双向 GRU 的反向分支是从序列末尾往开头读的，所以在原始时间顺序下，反向分支的"最后一步"对应的是序列的第一个位置。

这意味着output[:, -1, :]的后半段（反向部分）实际上是反向分支读完整条序列之后的状态，它对应的语义位置是序列的开头。如果你把它当成"句尾特征"来用，逻辑就错了。

对于定长序列这个问题不明显，因为所有位置都有有效内容。但对于 padding 过的变长序列，output[:, -1, :]的反向部分对应的是 padding 区域还是第一个有效词，取决于你有没有做大调整。一旦搞混，模型可能仍然能训练，但收敛会变慢，效果不稳定。

我的建议是，双向模型要取全局表示，一律走h_n拆分拼接那条路，或者用带 mask 的池化。不要图省事直接切output[:, -1, :]。

6. 常见报错与排查技巧实录

前面讲的是原理和正确用法，这一节讲实战里最容易撞到的问题。我把这几年遇到的典型报错整理成了一张速查表，遇到问题先对照，能省不少时间。

6.1 形状类报错速查表

这张表里最值得说的是第一条。nn.GRU和nn.GRUCell的区别就在这里。GRUCell只处理一个时间步，输入是二维的(batch, input_size)，适合你想自己写循环、需要在中途插入自定义逻辑的场景。GRU处理整个序列，输入必须三维。两者名字很像，但输入要求完全不同，选错了就会一直报维度错误。判断标准很简单：如果你需要在每个时间步之间做额外操作，比如注意力、条件判断、动态停止，就用GRUCell；如果只是标准的序列编码，用GRU更快更省事。

6.2 dtype、device 与 dropout 的隐性坑

形状问题解决之后，剩下的坑大多是隐性的，不报错但影响结果。

一个是 dtype。混合精度训练时，如果h_0手动创建的时候没指定dtype，默认是float32，与float16的输入不匹配，会报一个expected scalar type Half but found Float的错误。解决方式就是在创建张量时统一用x.dtype和x.device。更省事的写法是直接不传h_0，让框架按输入自动创建，这样 dtype 和 device 都不会错。

另一个是 device。模型在 GPU 上但h_0在 CPU 上时，报错信息有时候不会直说是设备问题，而是给一个比较绕的维度错误。所以养成习惯，凡是在 forward 里新建张量，一律带上device=x.device。

第三个是 dropout 的警告。前面提过，num_layers=1时传非零 dropout 会有一条UserWarning。这条警告有些人直接忽略了，但在做对比实验时会产生误解，以为自己加了正则化其实没有。看到这条警告就老老实实把 dropout 设成 0，或者把层数加到 2 以上。

还有一个小坑跟batch_first的切换有关。有些开源代码在内部用了默认的batch_first=False，然后在你传数据的地方做了transpose。如果你接手这类代码又改了batch_first，很可能只改一处，导致输入和输出一边转置了另一边没转，模型能跑但学不对。接手别人代码时先全局搜一下batch_first和transpose(0, 1)出现的位置，心里有数再动手。

6.3 参数初始化与性能调优经验

默认的初始化对 GRU 来说能用但不算最优。循环权重用正交初始化通常能改善梯度传播，输入权重用 Xavier 也比我见过的默认均匀分布更稳。

def init_gru_weights(module): for name, param in module.named_parameters(): if "weight_ih" in name: nn.init.xavier_uniform_(param) elif "weight_hh" in name: nn.init.orthogonal_(param) elif "bias" in name: nn.init.zeros_(param) model.apply(init_gru_weights)

如果希望初始时更新门偏向"保留旧状态"，可以把更新门对应的偏置设成正值，这样sigmoid的输出大于 0.5，更倾向于记住历史。不过这个技巧对长序列更明显，短序列任务里差别不大，属于可选优化。

性能方面有几个实测有效的做法。第一，保证在 GPU 上跑，GRU 的 GPU 加速比 CPU 快一个数量级以上，而且批次越大优势越明显，因为按时间步展开的循环可以在 batch 维度上并行。第二，hidden_size对齐到 8 的倍数（比如 128、256、512）在一些硬件上能更快，这个优势不像卷积那么显著，但试试不亏。第三，num_layers增加的收益通常小于把hidden_size加大带来的收益，但层数多了会让梯度传得更深、训练更难。我一般先固定层数为 1 或 2，把hidden_size调到一个合理值，再考虑加层。

速度上 GRU 比同配置的 LSTM 快一些，因为门少了一个，参数量和计算量都小。如果你的任务对精度要求不是极致，GRU 通常是性价比更高的选择。我做过一个中文短文本分类的对比，同样的训练轮数下，GRU 的准确率只比 LSTM 低零点几个百分点，但单轮训练时间少了大约四分之一，调试迭代的体验明显更好。

最后说一个我自己的习惯。每次新写一个 GRU 相关的模块，我会先写三四行断言，把输入输出的形状全部打出来确认一遍，包括output、h_n、以及下游输入的形状。这几行代码跑一次只要几百毫秒，但能省掉后面几十分钟的调试。特别是涉及多层加双向的组合时，纸面上推算很容易出错，跑一下最踏实。

上面这些内容基本覆盖了torch.nn.GRU从输入到输出的全部关键点。我个人在实际操作中的体会是，形状这件事并不复杂，难的是双向和多层叠加之后的组合，以及 padding 这种不报错但会悄悄影响结果的问题。把第 3 节的对照表和第 5 节的 pack 用法记住，日常开发里遇到的大部分情况都能应付。