企业官网建设流程全解析

1. 一个再常见不过的困惑：用了一年 nn.LSTM，参数还是背不出来

先从一个现象说起。很多同学在搭建序列模型时，第一反应就是nn.LSTM(input_size, hidden_size, num_layers=2)，然后丢进去一个三维张量，跑通之后就不再管了。直到某天需要改双向、加 dropout，或者把 batch 维度从第 0 维换成第 1 维，各种 RuntimeError 就冒出来了。更麻烦的是，模型能跑，但训练曲线发散，loss 居高不下，翻来覆去查不出原因。

我见过不止一个人把batch_first=True设置好，但自己喂数据时依然把形状写成(seq_len, batch, input_size)，导致模型“假装正常”地训练了很久，精度却一直上不去。这类问题在 LSTM 里尤其隐蔽，因为它不像卷积层那样对输入尺寸有强约束，只要维度数量对、最后一维对得上，它就能给你算，至于你心里想的“这个维度是 batch 还是 time step”，它根本不关心。

所以我认为，真正弄懂 nn.LSTM 不是去背那几个参数名，而是搞清楚三件事：每个参数在内部怎么改变张量流动、输入输出形状在数学上如何推导、以及训练时隐藏状态的管理方式。这三件事想通了，模型能不能收敛、能不能处理变长序列、双向到底怎么拼接，都会变得非常清晰。

这篇文章我会从一个经常拿 nn.LSTM 做文本分类、时间序列预测的实践者角度，把参数、形状、门控原理、实战案例和踩坑记录全部串起来讲，适合已经会跑 PyTorch 基础代码、但对循环神经网络细节还不够笃定的读者。

2. nn.LSTM 七个构造参数背后的真实作用

2.1 input_size：它管的不是整个序列，而是单个时间步

input_size这个参数特别容易被误解。有人以为它代表输入序列的长度，其实不是。它表示的是输入序列中每一个时间步的特征维度。

举个例子，如果你在做英文情感分类，每个样本是一条句子，经过分词和词嵌入后每个词变成一个 100 维的向量，句子长度是 20 个词，那么你的输入张量形状是(seq_len=20, batch=64, input_size=100)，这里的input_size必须传 100。如果我们直接做温度预测，每个时间步只有温度一个数值，那input_size=1。

我在自己的项目里经常把这称为“单步特征数”。判断方法很简单：把你的序列数据按时间轴切一刀，看切出来的那个横截面最后有多少个通道或特征，那就是input_size。

2.2 hidden_size：输出维度、记忆容量、权重规模三者绑定

hidden_size是 LSTM 细胞中隐藏状态向量的长度。它同时决定了三个东西：

• 每个时间步的输出特征维度；
• 隐藏状态h_t和细胞状态c_t的维度；
• 所有门控权重矩阵的第二维或第一维规模。

数值越大，模型表达能力越强，但参数量会按平方级别增长，因为输入到隐藏层的权重是4 * hidden_size * (input_size + hidden_size)。以input_size=100、hidden_size=256为例，仅输入到隐藏层这一组权重就有4 * 256 * 356 ≈ 36.5 万个参数，如果再乘上多层和双向，训练压力会非常明显。

2.3 num_layers：堆叠 LSTM 时隐藏状态层层传递

num_layers表示将几个 LSTM 层纵向堆叠起来。第一层接收原始输入x，第二层接收第一层的输出序列，以此类推。每一层都有自己的权重和偏置，参数名字也按l0、l1依次命名。

初学者经常忽略一个关键点：堆叠状态下，中间层的输入维度是上一层的hidden_size，而不是原来的input_size。例如nn.LSTM(input_size=100, hidden_size=128, num_layers=3)，在内部逻辑里：

• 第 0 层：输入是(seq_len, batch, 100)，输出(seq_len, batch, 128)
• 第 1 层：输入是(seq_len, batch, 128)，输出(seq_len, batch, 128)
• 第 2 层：输入是(seq_len, batch, 128)，输出(seq_len, batch, 128)

如果各层hidden_size不一致，就得手动拆分或者改用自定义循环，nn.LSTM 自身不允许逐层指定不同的hidden_size，这是一个很容易被误会的设计。

2.4 bias：关掉它的情况极少，但确实存在

bias=True是默认值，会给每个门控都配一个偏置向量。何时需要关掉？一个典型场景是你已经在前面的 Embedding 层或其他结构里做了偏置补偿，或者你在做某些需要严格控制参数量的部署场景，又或者做权重初始化实验时需要完全去掉偏置项来观察纯权重的影响。

但绝大多数情况下，我建议保留偏置。LSTM 的遗忘门偏置还承担着一个实际作用：初始化时把遗忘门的偏置设大一些（比如 1 或 2），可以让模型在训练初期倾向于记住信息，这在长序列任务中对稳定训练很有帮助。如果你手动关了 bias，这个调优空间就没有了。

2.5 batch_first：不改变数据，只改变你的心智模型

batch_first默认是False，也就是输入格式为(seq_len, batch, input_size)。设成True后，输入变成(batch, seq_len, input_size)。

这里有个常见误区：很多人以为设了batch_first=True之后，LSTM 对数据的处理方式改变了。实际上没有，它只是在内部做了一次转置，把数据恢复到标准格式再计算。这个参数真正的价值在于，当你把 LSTM 放在一个数据批次已经是batch在前的数据管道里时，能减少你手动transpose的出错概率。

但要注意，隐藏状态和输出中时间步的顺序不会因为你改了batch_first而改变。输出永远是(batch, seq_len, hidden_size)或(seq_len, batch, hidden_size)，具体取决于你设置的值。理解了这一点，很多形状错乱的问题就迎刃而解。

2.6 dropout：只在层间生效，最后一层不会加

dropout参数必须配合num_layers > 1才有意义。它表示在除最后一层之外的各层输出上，施加一个概率为p的 Dropout。也就是说，如果num_layers=1，无论 dropout 设多少，都不会生效，PyTorch 也不会报错，只是静默忽略。

这在实践中容易造成两个问题。第一个是“我以为加了正则，其实没加”；第二个是“测试时忘记切换model.eval()”，导致推理时 Dropout 仍在工作，输出抖动厉害。虽然这不只是 LSTM 特有的问题，但 LSTM 的中间状态传递特性会让这种抖动在序列维度上放大，产生看起来像“模型疯了”一样的效果。

2.7 bidirectional：输出维度直接翻倍，拼接方向决定下游设计

bidirectional=True时，LSTM 会同时用正向和反向两个方向处理序列。每个方向都有自己的权重和隐藏状态，最终的状态输出是拼接在一起的，所以维度变成2 * hidden_size。

需要注意三点。第一，如果bidirectional=True且num_layers=2，那么中间层的输入维度要能承接双向输出，也就是说第二层的输入维度自动变成2 * hidden_size，这些细节 PyTorch 会帮你处理好，不需要手动指定。第二，h_n和c_n的第一维不再是num_layers，而是num_layers * 2，其中前半是正向各层，后半是反向各层。第三，如果你想取最后一个时间步的输出作为分类特征，不能简单取output[:, -1, :]，因为对反向层来说，末尾其实是序列的起点，你需要把h_n按方向拆开再拼接。

3. 输入输出形状推演：从一批原始数据到 h_n、c_n 的全过程

3.1 最标准的张量格式

先记住一个基准：不管有没有设置batch_first，nn.LSTM 内部遵循的始终是(seq_len, batch, input_size)这个逻辑顺序。batch_first只是一个“入口转换器”。

举个例子。假设有一批 32 条评论，每条评论截断到 50 个词，每个词用 300 维 GloVe 向量表示。那么在batch_first=True的情况下：

import torch import torch.nn as nn lstm = nn.LSTM(input_size=300, hidden_size=128, num_layers=2, batch_first=True) x = torch.randn(32, 50, 300) # batch=32, seq_len=50, input_size=300 output, (h_n, c_n) = lstm(x) print(output.shape) # torch.Size([32, 50, 128])

这里output的第二个维度是seq_len，因为batch_first=True时输出会自动调整回(batch, seq_len, hidden_size)。每个时间步的output[t]实际上对应第 t 个词输入后 LSTM 细胞给出的隐藏状态。

3.2 初始状态 h_0、c_0 的形状推导

如果不传h_0和c_0，PyTorch 默认用全零张量初始化，这可能就是很多任务在序列较短时还能正常工作的原因。但如果你要传递自定义初始状态，必须保证形状是：

(num_layers * num_directions, batch, hidden_size)

其中num_directions在单向时为 1，双向时为 2。

这里的推导逻辑是：每一层、每个方向都有自己的独立隐藏状态，所以第一维根据层数和方向数相乘。我在处理多批次推理时，经常用下面这个模式生成初始状态：

def init_hidden(batch_size, hidden_size, num_layers, bidirectional=False): num_directions = 2 if bidirectional else 1 h0 = torch.zeros(num_layers * num_directions, batch_size, hidden_size) c0 = torch.zeros(num_layers * num_directions, batch_size, hidden_size) return h0, c0

函数返回的h_n、c_n不包含 batch 维度吗？其实包含，这里batch_size就是第二维。有一个容易混淆的点：PyTorch 文档中h_n的形状写的是(num_layers * num_directions, batch, hidden_size)，注意它不是(num_layers, batch, hidden_size * num_directions)，这两个形状在数值语义上完全不同。

3.3 双向 LSTM 的输出拼接到底是怎么拼的

output的最后一维永远是hidden_size * num_directions，这意味着正向和反向两个隐藏状态按特征维度直接拼接，而不是在时间步上进行某种“平均”或“取最大值”。具体取法如下：

# 正向最后一个时间步的隐藏状态：把 h_n 拆开 h_n_forward = h_n[0] # (batch, hidden_size) h_n_backward = h_n[1] # (batch, hidden_size) combined = torch.cat([h_n_forward, h_n_backward], dim=-1) # (batch, 2*hidden_size)

如果你只想要整个序列的“总结向量”，通常的做法是取output[:, -1, :hidden_size]拼上output[:, 0, hidden_size:]。这也解释了为什么很多双向 LSTM 分类模型会写一个自定义的forward，而不是直接拿output[:, -1, :]当最终特征。

3.4 变长序列与 pack_padded_sequence 的形状变化

实际项目里句子长度几乎不可能完全一致。如果直接 pad 成等长，无意义的 pad 位置会让 LSTM 白白计算，更严重的是会污染最后一步隐藏状态。解决方式是使用pack_padded_sequence和pad_packed_sequence。

from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence # lengths 是降序排列的每个样本实际长度 packed, (h_n, c_n) = lstm(pack_padded_sequence(x, lengths, batch_first=True)) output, _ = pad_packed_sequence(packed, batch_first=True)

packed会把有效时间步紧凑地打包在一起，LSTM 只在真实序列长度内计算，反向传播时梯度也只会流经有效部分。这一点在工业级数据处理流程中几乎是标配，很多入门教程却不提。

常见的坑是：传入pack_padded_sequence的lengths必须按降序排好，或者配合enforce_sorted=False参数使用。如果你用的是默认enforce_sorted=True，没排序就会得到一个报错，或者更糟，得到一个“数值正确但顺序错乱”的结果。

4. 门控单元与权重形状：读懂 nn.LSTM 内部到底存了什么

4.1 LSTM 的四个门在做什么

LSTM 的核心思想是引入一条细胞状态c_t的传送带，信息可以在序列时间步之间近乎无损地传递，同时通过三个门控制信息的写入和遗忘。

• 遗忘门：决定上一时刻的细胞状态中哪些信息要丢弃；
• 输入门：决定当前候选细胞状态中有哪些新信息要写入；
• 细胞更新：把旧状态乘以遗忘门的结果，再加上输入门和候选状态的乘积；
• 输出门：决定最终要暴露多少细胞状态到当前隐藏状态。

PyTorch 的 nn.LSTM 把这四组计算封装成一个复合函数。从外部看不出门控细节，但权重矩阵的结构是有明确规律的。

4.2 权重矩阵的命名与维度拆解

你可以通过以下方式查看 LSTM 层内部的所有参数：

lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2) for name, param in lstm.named_parameters(): print(name, param.shape)

输出大致是：

weight_ih_l0 torch.Size([80, 10]) weight_hh_l0 torch.Size([80, 20]) bias_ih_l0 torch.Size([80]) bias_hh_l0 torch.Size([80]) weight_ih_l1 torch.Size([80, 20]) weight_hh_l1 torch.Size([80, 20]) bias_ih_l1 torch.Size([80]) bias_hh_l1 torch.Size([80])

第一维是 80，正好等于4 * hidden_size，也就是四个门控各自需要一份权重。这 80 行的排列顺序是固定的：输入门、遗忘门、细胞候选、输出门。

如果你想自己实现一个 LSTM 的前向计算，或者做一些自定义初始化，可以直接按这个顺序拆分：

w_ih = lstm.weight_ih_l0 # 形状 (4*hidden_size, input_size) w_i, w_f, w_g, w_o = w_ih.chunk(4, dim=0)

这里w_i对应输入门，w_f对应遗忘门，w_g对应细胞候选，w_o对应输出门。看懂这个布局后，你就会理解为什么网上有些人用chunk(4, dim=0)去检查网络能不能收敛——因为任何一个门控初始化得不好，都可能让梯度消失或爆炸。

4.3 自定义初始化时的常见误区

对 LSTM 做初始化，最简单的做法是遍历参数，根据门的顺序分别用不同的分布初始化。例如遗忘门偏置初始化为较大正值，已经被很多研究证实能提升长序列性能：

def init_lstm_weights(lstm): for name, param in lstm.named_parameters(): if 'weight_ih' in name: torch.nn.init.xavier_uniform_(param) elif 'weight_hh' in name: torch.nn.init.orthogonal_(param) elif 'bias' in name: # 四个门：i, f, g, o 各占 hidden_size hidden_size = param.size(0) // 4 param.data.fill_(0) param.data[hidden_size:2 * hidden_size].fill_(1.0) # 遗忘门偏置

这里把遗忘门偏置初始化为 1，能显著缓解长序列训练初期的“短期记忆偏好”问题。需要注意的是，bias有bias_ih_lx和bias_hh_lx两组，它们维度一样，但一个是输入到隐藏投影的偏置，一个是隐藏到隐藏投影的偏置，初始化时可以一起处理。

4.4 为什么说 nn.LSTM 内部是“不可并行”的

这是 LSTM 与 Transformer 在速度上差异巨大的根本原因。LSTM 在时间步上的计算存在严格的依赖：计算 t 时刻的隐藏状态，必须等 t-1 时刻的结果出来。PyTorch 的 nn.LSTM 虽然底层是高度优化的 CUDA 内核，但本质上依然是逐步计算，序列越长，耗时线性增长。

这不是参数层面的问题，而是循环结构所固有的。理解了这一点，你就能明白为什么很多工业场景在序列长度超过几百时，会逐渐用 CNN 或 Attention 结构替代 LSTM。不过，对于中等长度、强时序依赖的任务，LSTM 仍然是一个稳定、好调、可解释性强的选择。

5. 完整实战：用 nn.LSTM 搭建一个文本情感分类模型

5.1 数据集与预处理

我们以 IMDB 电影评论情感分类为例，目标是判断一段评论是正面还是负面。这里不会涉及太复杂的数据集，重点是用一个小而完整的示例展示 nn.LSTM 的参数如何组装进真实任务。

import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader from collections import Counter # 假设 texts 和 labels 已经是你加载好的数据 # texts: list[str]，labels: list[int]，1 代表正面，0 代表负面

先构建词汇表，把每条评论里的词转成索引。

vocab = Counter() max_vocab_size = 20000 for text in texts: vocab.update(text.split()) vocab_size = min(len(vocab), max_vocab_size) + 2 word2idx = {w: i + 2 for i, w in enumerate(vocab.most_common(max_vocab_size))} PAD, UNK = 0, 1 word2idx['<pad>'] = PAD word2idx['<unk>'] = UNK def encode(text, max_len=100): tokens = [word2idx.get(w, UNK) for w in text.split()][:max_len] tokens = tokens + [PAD] * (max_len - len(tokens)) # 短于 max_len 的补齐 return torch.tensor(tokens, dtype=torch.long)

max_len的选择是一个模型设计参数，当评论很长时，设得太小会丢掉后半段关键信息，设得太大则会让训练变慢。IMDB 评论平均长度在 200 词左右，这里取 100 是为了示例速度，实际工程里建议先统计长度分布，取一个能覆盖 90% 样本的长度。

5.2 模型定义：把 nn.LSTM 参数全部用上

这里我构建一个双层双向 LSTM，再接一个全连接分类头。通过这个例子，你能看到hidden_size、num_layers、batch_first、bidirectional和dropout在真实模型里的位置。

class LSTMSentimentClassifier(nn.Module): def __init__(self, vocab_size, embed_size=100, hidden_size=128, num_layers=2, num_classes=2, dropout=0.3): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0) self.lstm = nn.LSTM( input_size=embed_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, dropout=dropout if num_layers > 1 else 0, bidirectional=True ) # 双向 LSTM 最后一维是 hidden_size * 2 self.classifier = nn.Sequential( nn.Dropout(dropout), nn.Linear(hidden_size * 2, hidden_size), nn.ReLU(), nn.Dropout(dropout), nn.Linear(hidden_size, num_classes) ) def forward(self, x, lengths): embedded = self.embedding(x) packed_embedded = pack_padded_sequence( embedded, lengths, batch_first=True, enforce_sorted=False ) packed_output, (h_n, c_n) = self.lstm(packed_embedded) # 双向的最后隐藏状态：拼接正向和反向 h_n_forward = h_n[-2] # 最后一层正向 h_n_backward = h_n[-1] # 最后一层反向 h_final = torch.cat([h_n_forward, h_n_backward], dim=-1) logits = self.classifier(h_final) return logits

这里取最后一层隐藏状态的方式需要注意。h_n的形状是(num_layers * num_directions, batch, hidden_size)。当num_layers=2、bidirectional=True时，排列顺序是：

• h_n[0]：第 1 层正向
• h_n[1]：第 1 层反向
• h_n[2]：第 2 层正向
• h_n[3]：第 2 层反向

所以取h_n[-2]和h_n[-1]，恰好就是最后一层的双向状态。这个索引规律几乎每次都会被搞错，我建议在模型里加一行断言或注释来提醒自己。

5.3 训练循环中的形状维护

训练时，一个需要特别注意的点是：pack_padded_sequence要求lengths是 CPU 上的整数张量，并且每个值不能超过该批次中序列的实际长度。你可以在 DataLoader 的collate_fn里统一处理。

def collate_batch(batch): texts, labels, lengths = [], [], [] for text, label in batch: encoded = encode(text) texts.append(encoded) labels.append(label) lengths.append((encoded != 0).sum().item()) # 按长度降序排序，方便使用 pack_padded_sequence order = sorted(range(len(lengths)), key=lambda i: lengths[i], reverse=True) texts = torch.stack([texts[i] for i in order]) labels = torch.tensor([labels[i] for i in order]) lengths = torch.tensor([lengths[i] for i in order]) return texts, lengths, labels

训练时的标准流程不用特别改，唯一要记得的是每个 batch 都重新生成隐藏状态，而不是跨 batch 传递。

model = LSTMSentimentClassifier(vocab_size=vocab_size) optimizer = optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() for epoch in range(5): model.train() total_loss = 0 for texts, lengths, labels in train_loader: optimizer.zero_grad() logits = model(texts, lengths) loss = criterion(logits, labels) loss.backward() optimizer.step() total_loss += loss.item() avg_loss = total_loss / len(train_loader) print(f'epoch {epoch}, loss: {avg_loss:.4f}')

一个新手的常见错误是忘了在每轮迭代开始时把上一轮的隐藏状态清零。如果初始化隐藏状态不小心用到了上一个 batch 的h_n，梯度会跨 batch 传播，造成训练不稳定。正规做法是：每次前向计算都不传初始状态，让 PyTorch 自动生成全零状态，这样就不会有这个问题。

5.4 推理时如何拿到概率和预测

模型推理时，记得先把模型切到 eval 模式，关闭 Dropout 对最终结果的随机影响。然后对输入做同样的预处理和 padding，最后从 logits 里取 softmax 概率。

model.eval() with torch.no_grad(): encoded = encode("this movie is fantastic and moving", max_len=20).unsqueeze(0) length = torch.tensor([(encoded != 0).sum().item()]) logits = model(encoded, length) prob = torch.softmax(logits, dim=-1) pred = torch.argmax(prob, dim=-1).item()

这里我观察到一个小坑：在推理单条样本时，batch=1，但 LSTM 的h_n中仍然带有 batch 维度，如果你把h_n拿出来直接用squeeze(0)，会把第一维当作 batch 给压掉，造成维度错误。更稳妥的方式是始终保留 batch 维度，只在需要分类特征时按维度索引。

6. 高频踩坑记录：形状报错和隐蔽 bug 的完整排查链路

6.1 经典的“Expected hidden size 4, got 8”错误

这个报错通常出现在你把hidden_size改了，但忘记同步修改初始状态h_0的维度时。例如原来单向 LSTM 的隐藏状态是(1, batch, 128)，后来改成双向，h_0需要变成(2, batch, 128)。很多人只改了bidirectional=True，却没有重建h_0，于是报错信息里会提示 hidden size 不匹配。

排查思路：

1. 看h_0的第一维是不是num_layers * num_directions；
2. 看h_0的第三维是不是hidden_size；
3. 打印模型每一层weight_ih_lx的形状，检查参数实际加载是否正确。

6.2 pack_padded_sequence 排序不一致导致预测结果错乱

如果lengths没按降序排序，而且你用的是enforce_sorted=True，PyTorch 在很多版本里不会直接报错，而是给出一个 RuntimeWarning，然后输出结果仍然可能保持“看似正常”的形状，但语义上已经错乱了。最隐蔽的情况是：你用了多个 reviewer 的数据，每个 batch 的排序方式不同，模型训练 loss 却很正常，但验证集上始终很差。

排查思路：

• 在collate_fn里打印lengths的前几项，确认是否严格降序；
• 直接调用pack_padded_sequence时，把enforce_sorted=False显式传进去，让 PyTorch 内部自动排序，避免手动排序的疏漏；
• 如果排过序，记得同步打乱texts和labels，否则标签对不上。

6.3 Dropout 没有生效，也没有报错

如果你的num_layers=1，然后设置了dropout=0.5，模型不会报错，也不会加 Dropout。很多人在做消融实验时，不仅没意识到这个问题，甚至以为加了 Dropout 反而让结果变差，于是得出“Dropout 对 LSTM 无效”的错误结论。

排查思路很简单：训练阶段打印嵌入层之后、LSTM 之前的张量，看每一个值是否都按概率被随机置零；或者直接检查state_dict，num_layers=1时模型里根本没有 Dropout 层，参数数量是一样的。

6.4 取最后一个时间步时，padding 位置影响分类结果

在不需要pack_padded_sequence的简化流程里，很多人会直接取output[:, -1, :]当作整条序列的表示。但问题是：如果序列做了 padding，最后几个时间步实际上都是<pad>标记，LSTM 在这些位置的隐藏状态会被无意义的 pad 污染。尤其是在文本分类任务里，padding 位置产生的隐藏状态会让分类向量偏向“空信息”方向。

一个临时方案是：根据lengths用gather取出每个样本真实末尾位置的隐藏状态：

# 假设 output: (batch, seq_len, hidden_size) idx = (lengths - 1).unsqueeze(-1).unsqueeze(-1).expand(-1, -1, output.size(-1)) last_states = output.gather(1, idx).squeeze(1)

当然，最推荐的做法还是前面提到的pad_packed_sequence，它在处理 padding 带来的额外计算和状态污染上更加彻底。

6.5 梯度爆炸和 NaN loss

LSTM 的梯度在长序列上非常容易出现爆炸，尤其是层数较多或hidden_size很大时。这个问题从参数角度出发，首要关注的是权重初始化：weight_hh如果初始过大会在时间维度上不断放大隐状态。其次是梯度裁剪。

# 在 optimizer.step() 之前 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)

我见过很多新人在 loss 变成 NaN 之后第一个想到的是调学习率，其实先做梯度裁剪，再把学习率从1e-3降到1e-4，往往就能解决。另外，如果输入数据里有非有限值（NaN 或 Inf），也会直接导致 LSTM 状态被污染，而且这种问题在序列中会逐时间步扩散，比全连接网络更严重。建议在数据加载阶段统一检查输入张量。

6.6 自定义初始状态的跨 batch 传递问题

有一种比较高级的用法是：在情感分类这种句子独立的任务中，让初始状态参与训练，或者把一个 batch 的最后状态当作下一个 batch 的初始状态。这在序列预测任务里是合理的，但在分类任务里是错误的设计，因为它会让模型隐式地“偷看”前一个 batch 的信息，导致评估指标虚高。

我的经验是：除非你有明确的连续性假设，比如股票价格、传感器信号这种同一时间源相邻片段拼接的情况，否则一律用全零初始化。连续性建模可以尝试h_n.detach()配合断点传递，但记得把梯度隔离，否则反向传播路径会跨多个 batch，训练极不稳定。

7. 关于参数选择的三个实战原则

7.1 先小后大，先浅后深

新项目里不要一上来就上num_layers=4、hidden_size=512的大型 LSTM。更合理的做法是先跑一个单层、hidden_size=64左右的基线模型，确认数据管道、loss 计算、评估代码都没有问题，再逐步增加规模和层数。

在基线模型上，LSTM 的收敛速度比 Transformer 慢，所以第一轮训练建议只跑 3 到 5 个 epoch，看 loss 是否稳定下降。如果 loss 不降或者剧烈震荡，优先排查学习率和数据归一化，而不是急着加复杂度。

7.2 hidden_size 的选择和输入维度相关

我的经验是，hidden_size可以设成input_size的 1 到 4 倍左右，在文本任务里 100 维嵌入对应 128 到 256 维隐藏状态是常见配置。如果隐藏状态太小，模型容量不足以捕捉序列中的长程依赖；太大则会导致过拟合和训练速度下降。更关键的是，hidden_size还会影响全连接分类头的输入维度，改一发动全身。

7.3 当你发现自己频繁做 transpose 时，说明batch_first该开了

这是个小技巧：如果你的代码中出现大量x.transpose(0, 1)或x.permute(1, 0, 2)，而且大部分是为了迎合 LSTM 的输入格式，那就应该直接在nn.LSTM里设batch_first=True，让整个数据管道保持统一的batch在前风格。batch_first不会带来性能损耗，它只是让你少写很多容易出错的转置代码。

我在实际项目中体会最深的一点是：LSTM 相关的 bug 往往不是算法理解不足，而是“维度心智模型”没有建立起来。如果你能闭上眼说出某一层 LSTM 的输入和输出形状，那么这个模块在你的工具箱里才算是真正熟了。