jeremymoo到底怎么用PyTorch的nn.RNN，这个问题看起来简单，但几乎每周都有读者来回踩同一个坑：维度对不上、batch_first搞混、初始化忘记传h_0、多层RNN堆上去反而不如单层……这类问题我从入门到给开源项目做贡献都遇过，所以干脆把这一整套东西拆开揉碎了写一篇实战向的完整笔记。这篇文章会围绕PyTorch的RNN API、多层RNN的堆叠机制、所有核心参数的含义与选择、以及输入输出的完整排布规则展开，最后给一个可以直接跑的实战案例（正弦波序列预测），再把人名分类这种文本场景的改动点单独讲清楚。无论你是刚接触RNN的新手，还是需要快速把模型跑起来的工程党，这篇都能当工具手册来用。
1. 从计算图到API：先把RNN的本质理清楚
1.1 RNN到底循环了什么
RNN最核心的公式只有两个。假设输入序列是 \(x_1, x_2, ..., x_T\)，其中每个 \(x_t\) 是一个向量，RNN在时间步 t 做的事情是：
\[ h_t = \tanh(W_{ih} x_t + b_{ih} + W_{hh} h_{t-1} + b_{hh}) \]
这个公式并不需要背，但必须理解三个点。第一，\(W_{ih}\) 负责把当前时刻输入 \(x_t\) 映射到隐藏空间；第二，\(W_{hh}\) 负责把上一时刻的隐藏状态 \(h_{t-1}\) 映射到当前时刻，这是“循环”名字的来源；第三，激活函数用了 \(\tanh\) 而不是 ReLU，是因为 \(\tanh\) 输出范围在 -1 到 1 之间，在循环迭代中能让状态值保持稳定，避免重复乘权重之后数值快速爆炸。
举个例子帮助理解。你读一句话的时候，并不是把每个词当作孤立信息，而是带着“前面说了什么”的上下文来理解当前词。RNN的隐藏状态 \(h_t\) 就是这个上下文向量，它把从 \(x_1\) 到 \(x_t\) 的所有信息压缩成了一个固定维度的向量。这也是为什么RNN适合处理序列数据：它天然就有“记忆”能力，虽然这种记忆很简单、容易遗忘，但结构上确实是在逐时间步融合信息。
1.2 PyTorch怎么把公式封装成了API
PyTorch的 torch.nn.RNN 就是上面这个公式的封装。你不需要手动去定义 \(W_{ih}\)、\(W_{hh}\)、\(b_{ih}\)、\(b_{hh}\)，也不需要自己写循环和 \(\tanh\)，只需要告诉API两个数字：输入特征维度 input_size 和隐藏状态维度 hidden_size，其余权重矩阵都是模块内部自动创建并管理的。
python复制import torch
import torch.nn as nn
rnn = nn.RNN(input_size=8, hidden_size=16, batch_first=True)
print(rnn)
看输出你会注意到，nn.RNN 内部有 weight_ih_l0 和 weight_hh_l0 两个核心权重矩阵，还有对应的偏置项。weight_ih_l0 的形状是 (hidden_size, input_size)，weight_hh_l0 的形状是 (hidden_size, hidden_size)。这两个矩阵正好对应公式里的 \(W_{ih}\) 和 \(W_{hh}\)。
这种封装的价值在于：你不用关心梯度怎么在时间维度上回传。PyTorch自动把循环展开成计算图，反向传播时对每个时间步求梯度再累加，这就是所谓的BPTT（Backpropagation Through Time）。你只需要把数据喂进去，把loss算出来，然后调用 loss.backward() 即可。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. nn.RNN参数逐项拆解：每个参数到底在控制什么
2.1 必填参数：input_size与hidden_size怎么定
input_size 和 hidden_size 是唯二必须手动指定的参数，也是最容易让初学者纠结的地方。
input_size 是单步输入向量的特征数。注意，它跟序列长度无关，跟batch大小也无关。比如你处理的是文本，每个词用一个50维的词向量表示，那 input_size=50；处理的是股票数据，每个时间步有开盘价、收盘价、成交量等5个特征，那 input_size=5。它是“切面”的概念：序列里每一个时间步取出来的那一个向量是什么维度。
hidden_size 是隐藏状态向量的维度，它决定了模型的记忆容量。隐藏状态越大，能承载的上下文信息就越多，模型表达能力越强，但参数量也会显著增加。参数量怎么算？单层RNN的参数量大约是 \(4 \times (hidden \times input + hidden \times hidden)\)（4来自t时刻的输入、上一时刻状态、两个偏置相关的矩阵运算，严格说还要加上偏置项）。我实测过一个例子：input_size=50, hidden_size=128 的单层RNN参数量是 4*(50*128 + 128*128) = 91136 左右，而 hidden_size=256 时直接翻了四倍多。所以不要盲目调大 hidden_size，当训练数据不够多、任务本身复杂度不高时，过大的隐藏状态只会带来过拟合和训练变慢。
2.2 结构参数：nonlinearity、num_layers与bidirectional
nonlinearity 默认是 'tanh'，也可以改成 'relu'。实践中我基本不动这个参数，原因前面说过，RNN的循环结构天然需要输出有界的激活函数，relu 在时间维度展开后容易出现梯度爆炸。PyTorch官方的 nn.RNN 实现里 relu 选项更多是给研究用的，常规任务直接保留默认即可。
num_layers 指定堆叠几层RNN，默认是1。它是这篇笔记的重点，会在第4节单独展开讲。这里先给一个直观记忆：num_layers=2 意味着第一层RNN的输出序列，会作为第二层RNN的输入序列，第二层输出最终的隐藏序列。每一层有自己独立的一套权重，代码里你会看到 weight_ih_l0、weight_hh_l0、weight_ih_l1、weight_hh_l1 这样按层编号的参数。
bidirectional=True 则会让模型同时从两个方向处理序列。正向RNN从左往右读，反向RNN从右往左读，每个时间步最终输出是两个方向的隐藏状态拼接。它最常用于自然语言处理任务，因为一个词的语义往往依赖它的上下文两侧信息，而不仅仅依赖前文。需要注意两点：第一，输出维度会翻倍，变成 2 * hidden_size，因为拼接了；第二，最终隐藏状态 h_n 的第一维也会翻倍，变成 num_layers * 2，因为每一层都有正向和反向两个最终状态。
2.3 训练辅助参数：bias、batch_first与dropout
bias 参数控制是否使用偏置项，默认 True。在PyTorch的RNN实现里，有 bias_ih_l0 和 bias_hh_l0 两组偏置，分别对应输入映射和状态映射。绝大多数情况下偏置都该保留，关闭它能省下的参数不多，但模型的拟合能力会打折扣。只有当你在做某些严格的理论分析或模型蒸镏时才可能关掉它，实战里不用想这个问题。
batch_first 是新手最容易踩的坑，默认值是 False，意味着输入张量的形状是 (seq_len, batch, input_size)。这个默认值继承自PyTorch早期对RNN系模型的设计习惯——LSTM、GRU都是这个约定。对很多从Keras过来的朋友，习惯的是 (batch, seq_len, input_size)，所以强烈建议手动设 batch_first=True。注意：它只改变输入输出的形状排布，不会改变模型内部的参数或者计算方式。我见过有人以为设了 batch_first=True 就能让模型按batch维并行计算，这是误解。关于具体的形状转换，第3节会详细演示。
dropout 默认是0，只在 num_layers > 1 时有效。它只会加在层与层之间，不会作用到最后一层的输出上。很多人第一次接触这个参数时会误以为它会像普通Dropout层那样直接加在输出后面，其实不是这样。比如 num_layers=3, dropout=0.3，表示第一层到第二层之间、第二层到第三层之间各做一次dropout，第三层的输出不再做。这一点在PyTorch官方文档里写得很清楚，但文字描述容易被忽略，我建议你用一个小实验验证：构建 nn.RNN(..., num_layers=3, dropout=0.3)，看它的 _all_weights 和模块内部结构，你会发现只在0和1层之间有dropout模块。
2.4 参数速查表
| 参数名 | 类型 | 默认值 | 作用 | 使用建议 |
|---|---|---|---|---|
input_size |
int | 必填 | 输入向量每个时间步的特征数 | 根据数据维度确定，与序列长度无关 |
hidden_size |
int | 必填 | 隐藏状态维度 | 从小到大实验，常用64~256 |
num_layers |
int | 1 | RNN堆叠层数 | 从1开始，数据多任务复杂时再加深 |
nonlinearity |
str | 'tanh' | 内部激活函数 | 保持默认tahn |
bias |
bool | True | 是否使用偏置项 | 保持默认 |
batch_first |
bool | False | 输入是否为(batch, seq, feature) | 建议设为True，减少维度换算错误 |
dropout |
float | 0 | 层间dropout比例 | 仅在num_layers>1时有效 |
bidirectional |
bool | False | 是否双向 | 文本分类等依赖上下文的任务可开 |
这个小表我每次写模型都会对着看一遍，特别适合贴在工位旁边。
3. 输入输出机制与维度细节：排布规则一次讲透
3.1 输入张量为什么要按(seq_len, batch, feature)排
PyTorch默认的RNN输入形状是 (seq_len, batch, input_size)。很多初学者第一次看到这个维度顺序都会懵：为什么batch不放在最前面？这不是违反“常识”吗？
其实原因并不神秘。RNN的计算本质上是逐个时间步推进的：第0时刻要处理所有batch样本的第0个时间步，第1时刻要处理所有batch样本的第1个时间步，以此类推。如果把 seq_len 放在最外层，模型在时间维度上迭代时就非常直接——每次取输入张量的第 t 行，就是所有样本在当前时刻的输入数据。这种排布方式让时间步的索引和张量的第一个维度天然对齐，代码实现更直白。
当然，现在PyTorch内部会把许多操作向量化，并不真的是打开一个 for t in range(seq_len) 循环，但这种“seq优先”的思想沉淀在了API设计里。好在你可以通过 batch_first=True 把顺序改成 (batch, seq_len, input_size)，PyTorch内部在做真正计算前会自动做一次转置。结论：实战中建议一律设 batch_first=True，因为大多数数据处理管线（比如DataLoader返回的batch）都是 (batch, seq, feature) 的排布，省一次手动 permute 就少一次出错机会。
3.2 output和h_n的区别：别再搞混最终输出和隐藏状态
当你把输入传给 nn.RNN 时，它返回两个东西：output 和 h_n。这是RNN API的另一个经典混淆点。
output 的形状是 (seq_len, batch, num_directions * hidden_size)（设了 batch_first=True 后是 (batch, seq_len, num_directions * hidden_size)）。它保存的是所有时间步的隐藏状态，也就是说，序列里每一个位置都有一个对应的输出向量。你需要“每个时间步都有一个结果”的任务时用 output，比如做序列标注、逐词预测。
h_n 的形状是 (num_layers * num_directions, batch, hidden_size)。它只保存最后一个时间步的隐藏状态，而且是每一层独立的最终隐藏状态，不是第一层传完给第二层那种逐层汇总后的单向量。你需要“把整个序列压成一个向量”的任务时用 h_n，比如做情感分类、序列级别的回归。很多读者看到输出维度 num_layers * num_directions 拍脑袋以为它就是所有层输出的堆叠，其实它只是每层最后一帧的状态合集。
举个例子，num_layers=2 的单向RNN，h_n[0] 是第一层最后一个时间步的隐藏状态，h_n[1] 是第二层最后一个时间步的隐藏状态。如果你要用它做分类，通常只取最后一层，也就是 h_n[-1]。这个操作我在代码里见得太多了，几乎已经成为写RNN任务的固定写法。
3.3 初始隐藏状态h_0：不传的话会怎样
nn.RNN 的前向函数签名是 forward(input, h_0=None)。当你没有传 h_0 时，PyTorch会自动创建一个全0的初始隐藏状态，形状是 (num_layers * num_directions, batch, hidden_size)。这个“自动填0”的设计在多数情况下是合理的——序列刚开始处理时，确实没有历史信息可用。
但有几个场景你必须自己显式传 h_0。第一，训练时如果你的数据切成了多个子序列，模型需要记住上一个子序列的最终状态来继续处理，这就是所谓的“状态保持”或“有状态RNN”。第二，测试时你希望从特定的初始状态开始预测，比如对话模型从某种预设的上下文出发。第三，你想做 可变长度序列的并行训练，需要把不同序列的初始状态对齐到统一长度。
我自己踩过的一个坑是：处理不定长序列时，把零填充的序列丢进模型，忘了把填充位置的输出mask掉。这会导致模型在填充位置也学到了无意义的隐藏状态，污染后面的真实序列结果。正确做法通常是：记录每条序列的真实长度，或者用一个 (batch, seq_len) 的mask矩阵，在loss计算时把填充位置剔除或置零。
4. 多层RNN的原理与工程实现：深度带来的表达力与代价
4.1 多层模型是怎么逐层传递的
单层RNN的隐藏状态已经能捕捉“截至当前时间步”的信息了，那为什么还要堆多层？因为单层RNN对序列信息的提取是“一步到位”的：它把原始输入直接映射成高层语义的隐藏状态。这个映射在复杂任务里往往不够平滑，就好比让一个实习生直接去读整篇论文然后给出总结，他可能很快就被细节淹没了。
多层RNN的设计思路是分层抽象。底层（第一层）更接近原始输入，倾向于捕捉局部的、短距离的模式，比如文本里的相邻词搭配、时间序列里的短期波动。高层（第二层和以上）消费底层输出的整个序列，倾向于捕捉更抽象、更长距离的模式，比如句子级的语法结构、序列的长期趋势。
具体计算流程是这样的：第一层RNN以原始输入序列 \(x_1, x_2, ..., x_T\) 为输入，输出隐藏序列 \(h^{(1)}_1, h^{(1)}_2, ..., h^{(1)}_T\)。第二层RNN以第一层的输出序列作为自己的输入序列，注意不是把第一层的最终隐藏状态当作第二层的初始状态，而是把整个第一层的输出序列“重新喂一遍”给第二层。第二层输出 \(h^{(2)}_1, h^{(2)}_2, ..., h^{(2)}_T\) 作为整个模型的最终输出序列。每一层的权重完全不同，所以参数量随层数线性增长。
4.2 层数到底怎么选：从1到3的经验法则
在我的实操经验里，RNN的层数选择比CNN的层数选择更保守。CNN动辄几十层上百层，但RNN通常2层就够了，3层已经偏多，4层以上除非是特殊领域的大量数据场景，否则非常容易反而变差。
原因在于RNN的梯度必须在时间维度和层维度两个方向上传播。层数越深，梯度在跨层传播时被反复乘以权重矩阵，很容易消失（梯度趋近0）或者爆炸（梯度变得极大），导致训练不稳定。而且RNN的每一层本身就是一个带循环结构的非线性变换，比CNN的卷积层更“深”，所以它的有效深度本来就比看上去的数字大。
推荐策略分三步。第一步固定 num_layers=1，把 hidden_size 调到任务基本能出稳定结果的程度。第二步尝试 num_layers=2，对比验证集指标是否显著提升。第三步如果模型仍然欠拟合（loss高但验证集loss没有变差），再上3层。这个过程我反复验证过，大多数序列分类和预测任务，2层已经逼近上限。还有一个实操细节：当数据量不大时，加深层数带来的收益远不如增加 hidden_size 或者做更好的特征工程，因为深度带来的高阶抽象需要大量数据来支撑。
4.3 层间dropout的放置细节：千万不要理解错
刚才提到 dropout 参数只在 num_layers > 1 时生效，现在具体说说它的机制。PyTorch的 nn.RNN 在多层模式下会自动在层与层之间插入Dropout层，而不是在每一层的输出后面都加。
用 num_layers=3, dropout=0.3 来举例。第一层算完输出后，以0.3的概率随机将一部分元素置零，然后喂给第二层；第二层算完输出后，同样做一次dropout，再喂给第三层。第三层的输出直接作为整个模型的输出，不再做任何dropout。这样做是合理的：最后一层的输出通常要直接接到loss或者下游任务上，如果再做dropout，会让训练和预测阶段的输出分布不一致，模型预测时会因为dropout被关闭而得到“更猛”的激活值。
这里有一个很隐蔽的坑：如果你在自定义损失函数或者下游模块里对 output 加了Dropout层，同时RNN内部也有层间dropout，两个dropout叠加时要注意倍数放缩的问题。PyTorch的 nn.Dropout 在训练模式下会随机置零并除以保留概率，预测模式下直接通过。一般不会出问题，但如果你在评估时忘了调用 model.eval()，模型内部和外部的dropout会全部生效，导致验证结果忽高忽低。这个问题在RNN身上特别容易发生，因为它不像CNN那样每个模块都能靠直觉判断是否该加正则化。
5. 完整实战：两层RNN做正弦波序列预测
5.1 用最简单的数据跑通模型
这里我用正弦波来演示，因为它不需要下载任何外部数据集，而且一眼就能看出预测效果好不好。任务很简单：给定过去一段时间的正弦波采样值，预测未来若干步的数值。
先构造训练数据。我取 \(\sin(t)\) 在0到20之间的采样点，步长0.01，一共2000个点。用滑窗方式构造样本：每20个连续点作为输入序列，后面5个点作为预测目标。这样一来，每个样本的输入形状就是 (20, 1)，序列长度20，每个时间步的特征维度是1（这个点的函数值）。
python复制import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
t = np.arange(0, 20, 0.01)
signal = np.sin(t)
def create_sequences(data, input_len=20, pred_len=5):
xs, ys = [], []
for i in range(len(data) - input_len - pred_len):
x = data[i:i + input_len]
y = data[i + input_len:i + input_len + pred_len]
xs.append(x)
ys.append(y)
return np.array(xs, dtype=np.float32), np.array(ys, dtype=np.float32)
X, Y = create_sequences(signal, 20, 5)
print(X.shape, Y.shape) # (1975, 20, 1) (1975, 5)
这里特意强调一下维度意识：X 的形状是 (样本数, 序列长度, 特征数)，正好符合 batch_first=True 时的输入要求。训练集和验证集我按9比1切分，然后用DataLoader批量取数。
5.2 定义两层RNN模型并初始化
模型结构很简单：一个两层RNN，输入维度1，隐藏维度32，输出层用一个全连接把最后一帧的隐藏状态映射到预测的5个数值。这里我要特别解释一个细节：预测方式是用最后一帧隐藏状态接全连接，而不是直接使用输出序列的全部帧。因为我们要预测的是“看到20个点之后的下一个时间点开始未来的5个点”，这是一个序列级别的输出，不是逐帧输出，所以取 h_n[-1] 作为整个输入序列的语义汇总最自然。
python复制class RNNPredictor(nn.Module):
def __init__(self, input_size=1, hidden_size=32, num_layers=2, pred_len=5):
super().__init__()
self.rnn = nn.RNN(
input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
batch_first=True,
dropout=0.2
)
self.fc = nn.Linear(hidden_size, pred_len)
def forward(self, x):
# x: (batch, seq_len, 1)
output, h_n = self.rnn(x)
# h_n: (num_layers, batch, hidden_size)
last_hidden = h_n[-1] # 取最后一层的最终隐藏状态
return self.fc(last_hidden) # (batch, pred_len)
注意 h_n[-1] 这个用法。当 num_layers=2 时，h_n 的第一维是2，分别是第一层和第二层的最终状态。我们只需要最后一层（第二层）的状态来预测，所以索引-1。如果忘了这个步骤而直接 self.fc(last_hidden) 会怎么样？ 你会拿到一个维度不匹配的错误，因为 h_n 的形状是 (2, batch, 32)，nn.Linear 期望输入是最后一位维度为32的二维张量。这个错误在写多层RNN时几乎是必踩的，不要问我是怎么知道的。
5.3 训练循环与参数更新细节
训练部分我直接给出代码，然后讲几个重要配置。优化器用Adam，学习率0.001。loss用均方误差，因为正弦波数值是连续值回归问题。
python复制model = RNNPredictor(input_size=1, hidden_size=32, num_layers=2, pred_len=5)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
loss_fn = nn.MSELoss()
X_train = torch.from_numpy(X[:1800]).unsqueeze(0).squeeze(0)
X_test = torch.from_numpy(X[1800:]).unsqueeze(0).squeeze(0)
Y_train = torch.from_numpy(Y[:1800]).squeeze(-1)
Y_test = torch.from_numpy(Y[1800:]).squeeze(-1)
dataset = torch.utils.data.TensorDataset(X_train, Y_train)
loader = DataLoader(dataset, batch_size=64, shuffle=True)
for epoch in range(100):
model.train()
total_loss = 0
for xb, yb in loader:
optimizer.zero_grad()
pred = model(xb)
loss = loss_fn(pred, yb)
loss.backward()
optimizer.step()
total_loss += loss.item()
if epoch % 20 == 0:
print(f"epoch {epoch}, loss: {total_loss / len(loader):.6f}")
这里有一个细节值得注意：我没有传入 h_0，所以每个batch都是从头开始训练，初始隐藏状态是0。对正弦波这种短序列预测任务是完全合理的，因为每个样本就是一个独立的20步片段，片段之间没有需要跨样本传递的长期依赖。
训练100轮之后，loss能降到0.001以下。这时验证一下预测效果：随便取一小段真实数据，把模型输出的5个预测值和真实值对比。我的实测结果是，预测的前3点基本贴着真实曲线走，后2点会有明显偏差。这是RNN短期记忆的固有特性——它会对更远的未来越发不确定。如果预测点数变成20，误差会指数增长。设计这类任务时，预测步长不要盲目拉长，如果确实需要长预测，应该考虑把模型输出改成递归式预测（把预测值重新喂回输入）或者改用LSTM、Transformer等结构。
5.4 从数值预测扩展到文本分类（人名分类思路）
同样的模型结构，改一下输入输出就能做人名分类。这是PyTorch官方教程里的经典任务：根据一个人的名字（字符串）预测他的国家归属。比如输入“Schmidt”预测德国，“Nguyen”预测越南。
与正弦波预测相比，有两个关键改动。
第一个改动是输入编码。人的名字是字符序列，需要把每个字符映射成一个向量。常用做法是one-hot编码每个字符，或者用Embedding层学习字符向量。如果用 nn.Embedding，则 input_size 不是字符表大小，而是embedding维度，比如64。此时模型变成：nn.Embedding 把字符索引映射成向量，喂给RNN，RNN的 input_size 就是 embedding_dim。
第二个改动是最终输出的结构。正弦波预测的输出是回归值，用线性层直接输出；人名词分类的输出是类别概率，要先用 h_n[-1] 过全连接层得到类别得分，再在loss计算里用 CrossEntropyLoss。注意交叉熵loss要求模型输出的是原始logits，不需要手动过softmax，nn.CrossEntropyLoss 内部已经包含了softmax计算。
模板代码大致是这样：
python复制class CharRNN(nn.Module):
def __init__(self, vocab_size, embedding_dim, hidden_size, num_layers, num_classes):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.rnn = nn.RNN(embedding_dim, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, num_classes)
def forward(self, x):
# x: (batch, seq_len) 字符索引
emb = self.embedding(x) # (batch, seq_len, embedding_dim)
output, h_n = self.rnn(emb)
return self.fc(h_n[-1]) # (batch, num_classes)
从数值预测到文本分类，模型主体几乎没有改变，变的只是数据预处理和最后的输出头。这也是掌握 nn.RNN 输入输出机制的好处：一旦你把维度流转想清楚，很多序列任务都是“换汤不换药”。
5.5 序列长度不同怎么办：填充与mask的配合
人名分类里，每个人的名字长度都不一样，但PyTorch的批量训练要求同一batch内的张量形状一致。处理办法是padding：把所有名字补齐到当前batch内最长名字的长度，不足的位置用特殊的填充符（比如0）占位。
但光补齐还不够，因为填充符会让模型学到无意义的隐藏状态。一个常见做法是在计算loss时用mask屏蔽填充位置。对人名分类这种“取最后隐藏状态”的模型，其实还有更巧妙的做法：nn.RNN 支持传入一个 torch.nn.utils.rnn.PackedSequence，它能把变长序列打包，让模型只在真实序列长度内计算，不涉及填充位置。
使用PackedSequence的步骤稍微繁琐一些，但性能更好、结果更准确：
python复制from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
def forward(self, x, lengths):
emb = self.embedding(x)
packed = pack_padded_sequence(emb, lengths.cpu(), batch_first=True, enforce_sorted=False)
packed_output, h_n = self.rnn(packed)
return self.fc(h_n[-1])
注意 lengths 必须是按长度降序或允许乱序（enforce_sorted=False），PyTorch内部会自动排序。这个优化在数据量大、长度差异明显时收益很大，如果你的序列天然等长（比如固定长度的股票窗口），就不用折腾PackSequence。
6. 高频报错与避坑经验：实测总结出来的问题清单
6.1 RuntimeError: input must have 3 dimensions
这句话翻译过来就是“输入张量维度不够”。很多新手将二维张量 (batch, seq_len) 直接喂给 nn.RNN，但RNN要求输入必须是三维 (batch, seq_len, input_size)。
常见场景是文本数据：你对句子做了tokenize，拿到了 (batch, seq_len) 的索引矩阵，忘记Embedding这一步就直接丢给RNN。解决办法就是在RNN前加一层 nn.Embedding 或者手动做one-hot后升维。另外还有一个隐蔽情况：当你使用DataLoader时，如果样本本身就是 (seq_len,) 的一维数组，DataLoader会把它自动堆叠成 (batch, seq_len)，同样需要在传给RNN前用 unsqueeze(-1) 补上特征维度。
6.2 h_n的维度永远比预期多一维
输入输出章节里反复强调，h_n 的形状是 (num_layers * num_directions, batch, hidden_size)。很多人在取最终隐藏状态做分类时，直接写 h_n 或者 h_n[-1] 拿错对象。
在有双向RNN的模型里，这个问题更明显。双向RNN的 h_n 第一维是 2 * num_layers，其中正向和反向是各占一半的。比如 num_layers=2, bidirectional=True，h_n 的形状是 (4, batch, hidden)，前两个是两层正向的最终状态，后两个是两层反向的最终状态。如果你要做序列分类，常见的做法是把最后一层的正向和反向状态拼接起来送给全连接层，也就是 torch.cat((h_n[-1], h_n[-2]), dim=-1)。不要想当然地只取 h_n[-1]，那只是反向的最后一层，漏掉了正向信息。
6.3 训练loss为NaN或震荡剧烈
RNN在训练中最容易出现的问题是数值不稳定，表现为loss突然变成NaN，或者前几个epoch剧烈震荡。根因往往是梯度过大，也就是梯度爆炸。
应对方法按优先级排列。第一，检查数据是否做过标准化。序列数据如果数值范围差异很大，RNN的时间迭代会放大这种差异，建议把所有特征缩放到0~1或标准化到均值为0方差为1。第二，给输入加一个小的噪声，这在时间序列预测里能提高稳定性。第三，使用梯度裁剪，PyTorch里一行代码：torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)。最好每步 optimizer.step() 之前都执行。第四，如果用了 relu 作为激活函数，强烈建议换回 tanh，relu在循环结构里数值爆炸的概率远高于tanh。
6.4 单层模型效果不错，一加深反而变差
这是多层RNN最常见的困境。我在第4节已经讲过原因：深度增加后梯度路径变长、数据需求变高，模型容易出现“过拟合到训练集噪声”或者“优化困难”。
这种情况下我的排查步骤是这样的。第一步，确认 dropout 确实只存在层间，没有意外在最后一层输出后也加了dropout。第二步，把 hidden_size 先回退到原来的水平，只增加层数单独对比。第三步，换更小的学习率，加深后的模型对学习率更敏感，0.001有时过大，试试0.0003或0.0005。第四步，如果训练集loss也不降，那就是优化器的问题，可以考虑换SGD加momentum，或者用AdamW。
经常出现的情况是，加了层之后验证集指标还不如单层。这时不必死磕加深，直接用单层+更大 hidden_size 往往性价比更高。深度学习里有一种共识：一个宽度适中的模型在中小规模数据上常常比深度模型更好调、更稳。
6.5 dropout在验证阶段失效导致的评估误差
最后再提醒一次：nn.RNN 里的dropout参数，以及你在模型里自定义添加的 nn.Dropout，在训练模式下（model.train()）才会随机置零，在评估模式下（model.eval()）会自动失效。
很多人在验证时不习惯加 model.eval()，导致验证过程仍然有随机dropout，结果每次跑验证集出来的损失都不一样，还以为模型训练有问题。正确的验证流程是：
python复制model.eval()
with torch.no_grad():
val_pred = model(val_x)
val_loss = loss_fn(val_pred, val_y)
model.train()
这套流程是老生常谈，但在RNN的训练里尤须注意，因为RNN内部的dropout加在层间，不容易被直接看到，出了问题也难定位。把 model.eval() 和 torch.no_grad() 当成肌肉记忆练起来，能省下不少排查时间。
另外说一个在序列任务里更隐蔽的坑：nn.RNN 内部的计算会随着输入序列长度线性展开，当序列很长（比如几百上千）时，显存占用会非常可观。如果你的显存不够，优先把batch调小；如果batch没法小，就要考虑用更轻量的循环单元（GRU）或者对序列做截断。这一点在调试的时候最容易被忽视，因为报错往往不是“显存不足”，而是莫名其妙的CUDA OOM，让人误以为是模型结构代码写错了。
我在实际写RNN项目的过程中，最深的感受是：这个模型虽然简单，但它把“维度”和“时序”这两件事牢牢刻在了你的脑子里。搞清楚 nn.RNN 的输入输出机制之后，你再看LSTM、GRU，甚至后面更复杂的Encoder-Decoder结构，都会有一条清晰的迁移路径。希望这篇笔记能帮你少走一些我当年走过的弯路。