首页/资讯中心/详情

从零到一：手把手复现LSTM+CRF序列标注经典论文

从零到一：手把手复现LSTM+CRF序列标注经典论文
📅 发布时间：2026/6/29 10:51:37

1. 为什么选择LSTM+CRF做序列标注

序列标注是自然语言处理中的基础任务之一，它的目标是为输入序列中的每个元素分配一个标签。比如在命名实体识别任务中，我们需要识别出句子中的人名、地名、组织机构名等实体。LSTM+CRF这个组合之所以能成为经典，是因为它巧妙地结合了两种模型的优势。

LSTM（长短期记忆网络）擅长捕捉序列数据中的长期依赖关系。举个例子，当我们看到"Apple"这个词时，单独看很难判断它是指水果还是公司。但如果前面有"buy"这个词，就更可能是水果；如果有"CEO"这个词，就更可能是公司。LSTM能够记住这样的上下文信息。

而CRF（条件随机场）则擅长处理标签之间的约束关系。比如在命名实体识别中，"I-ORG"（组织机构内部）不应该跟在"B-PER"（人名开始）后面。CRF可以在全局范围内考虑这种标签转移概率，避免不合理的标签序列。

我在实际项目中发现，单独使用LSTM时，模型可能会输出违反常识的标签序列。而加入CRF层后，这种错误明显减少。特别是在处理长句子时，CRF的全局优化能力表现得尤为突出。

2. 环境准备与数据预处理

2.1 安装必要的库

复现这个模型需要准备以下Python库：

  • PyTorch：深度学习框架
  • TorchCRF：CRF层的实现
  • NumPy：数值计算
  • Matplotlib：绘制训练曲线

可以通过以下命令安装：

pip install torch torchcrf numpy matplotlib

2.2 数据格式解析

我们使用CoNLL2003数据集，这是序列标注的经典基准数据集。原始数据格式是这样的：

EU B-ORG rejects O German B-MISC call O to O boycott O British B-MISC lamb O . O

每行包含一个单词和对应的标签，句子之间用空行分隔。标签采用BIO标注方案：

  • B-XXX：某类实体的开始
  • I-XXX：某类实体的内部
  • O：非实体

2.3 构建词汇表和标签表

这是整个流程中容易被忽视但非常重要的一步。我们需要：

  1. 收集所有出现过的单词，分配唯一ID
  2. 收集所有标签类型，分配唯一ID
  3. 添加特殊标记如<pad>用于填充

这里有个坑要注意：测试集中可能出现训练集未见的单词。好的做法是预留一个<unk>标记，并为这些未知单词分配这个ID。

def build_vocab(sentences): vocab = set() for sentence in sentences: vocab.update(sentence.split()) return {word:i for i,word in enumerate(vocab)} word2idx = build_vocab(train_sentences) word2idx['<pad>'] = len(word2idx) # 填充标记 word2idx['<unk>'] = len(word2idx) # 未知单词

3. 模型架构详解

3.1 嵌入层(Embedding Layer)

嵌入层负责将离散的单词ID转换为连续的向量表示。这里有几个关键点：

  1. 向量维度（embedding_size）：论文设为50，这是一个经验值。维度太小会丢失信息，太大则增加计算量。

  2. 初始化方式：可以使用预训练的词向量（如GloVe），也可以随机初始化让模型自己学习。在资源充足的情况下，我推荐使用预训练词向量。

self.embedding = nn.Embedding(vocab_size, embedding_size) if pretrained_vectors: # 如果使用预训练词向量 self.embedding.weight.data.copy_(pretrained_vectors)

3.2 LSTM层配置

LSTM层的配置直接影响模型性能，有几个参数需要特别注意：

  1. hidden_size：隐状态维度，论文设为300。更大的维度能捕捉更复杂模式，但也更容易过拟合。

  2. bidirectional：是否使用双向LSTM。原论文使用的是单向，但实践中双向通常效果更好。

  3. batch_first：PyTorch的LSTM默认期望输入形状为(seq_len, batch, features)。设为True可以让输入变为(batch, seq_len, features)，更符合直觉。

self.lstm = nn.LSTM( input_size=embedding_size, hidden_size=hidden_size, batch_first=True, bidirectional=False # 按照论文配置 )

3.3 CRF层实现

CRF层是模型的关键部分，它通过转移矩阵建模标签之间的约束关系。需要注意：

  1. 转移矩阵的初始化：通常初始化为0，但可以给不可能的转移（如O→I）设置很大的负值。

  2. 解码算法：使用Viterbi算法找到最优标签序列。

from torchcrf import CRF self.crf = CRF(num_tags=len(tag2idx), batch_first=True)

4. 训练技巧与调参经验

4.1 处理变长序列

自然语言句子长度不一，我们需要：

  1. 记录每个句子的实际长度
  2. 用pad_sequence填充到统一长度
  3. 使用pack_padded_sequence告诉LSTM忽略填充部分
# 填充序列 padded_sequence = pad_sequence(sequences, batch_first=True) # 打包序列 packed_input = pack_padded_sequence( padded_sequence, lengths=lengths, batch_first=True, enforce_sorted=False )

4.2 损失函数与优化

CRF层的损失函数是负对数似然。优化时要注意：

  1. 学习率：论文使用0.1，但实践中0.001更稳定
  2. 梯度裁剪：防止梯度爆炸，设置max_norm=0.5
  3. 批次大小：论文使用100，但根据显存调整
optimizer = torch.optim.Adam(model.parameters(), lr=0.001) loss = -model.crf(emissions, tags, mask=masks) # CRF损失 loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5) optimizer.step()

4.3 评估指标

不要只看准确率，序列标注任务更关注：

  1. F1分数：精确率和召回率的调和平均
  2. 按实体类别的细分指标：有些类别可能表现较差
def compute_f1(preds, targets): # 计算真阳性、假阳性、假阴性 tp = ((preds == targets) & (targets != 0)).sum() fp = (preds != targets).sum() fn = ... precision = tp / (tp + fp) recall = tp / (tp + fn) return 2 * precision * recall / (precision + recall)

5. 常见问题与解决方案

5.1 内存不足问题

当遇到CUDA out of memory错误时，可以尝试：

  1. 减小batch_size
  2. 使用梯度累积：多次小批次计算后再更新参数
  3. 混合精度训练：使用torch.cuda.amp
scaler = torch.cuda.amp.GradScaler() with torch.cuda.amp.autocast(): outputs = model(inputs) loss = criterion(outputs, targets) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

5.2 标签不平衡问题

序列标注中O标签往往占大多数，这会导致模型偏向预测O。解决方法：

  1. 对非O标签的损失加权
  2. 采样时平衡不同标签的比例
  3. 使用focal loss
class_weights = 1.0 / torch.bincount(tags.flatten()) criterion = nn.CrossEntropyLoss(weight=class_weights)

5.3 模型不收敛

如果训练损失不下降，可以检查：

  1. 学习率是否合适
  2. 梯度是否消失/爆炸
  3. 数据预处理是否有误
  4. 模型初始化是否合理

一个实用的调试技巧是先在极小数据集上过拟合，确保模型有能力记住训练样本。如果连训练集都学不好，说明模型或代码有问题。

6. 进阶优化方向

6.1 使用预训练语言模型

用BERT等预训练模型替换Embedding层可以显著提升性能。实践中，我通常：

  1. 冻结BERT的前几层
  2. 只微调最后几层
  3. 结合CRF层使用
from transformers import BertModel self.bert = BertModel.from_pretrained('bert-base-uncased') # 获取BERT嵌入 outputs = self.bert(input_ids, attention_mask=mask) embeddings = outputs.last_hidden_state

6.2 注意力机制增强

在LSTM后加入注意力层，让模型聚焦于关键词语：

self.attention = nn.Linear(hidden_size, 1) lstm_out, _ = self.lstm(embeddings) attention_weights = torch.softmax(self.attention(lstm_out), dim=1) context = torch.sum(attention_weights * lstm_out, dim=1)

6.3 领域自适应技巧

当目标领域数据不足时，可以：

  1. 在通用领域预训练，再在目标领域微调
  2. 使用对抗训练减少领域差异
  3. 添加领域特定的特征工程

7. 完整代码实现

以下是整合了所有关键组件的完整模型代码：

import torch import torch.nn as nn from torchcrf import CRF class LSTM_CRF(nn.Module): def __init__(self, vocab_size, tag_to_ix, embedding_dim, hidden_dim): super(LSTM_CRF, self).__init__() self.embedding_dim = embedding_dim self.hidden_dim = hidden_dim self.vocab_size = vocab_size self.tag_to_ix = tag_to_ix self.tagset_size = len(tag_to_ix) self.embedding = nn.Embedding(vocab_size, embedding_dim) self.lstm = nn.LSTM(embedding_dim, hidden_dim // 2, num_layers=1, bidirectional=True, batch_first=True) self.hidden2tag = nn.Linear(hidden_dim, self.tagset_size) self.crf = CRF(self.tagset_size, batch_first=True) def forward(self, x, tags, mask): embeds = self.embedding(x) lstm_out, _ = self.lstm(embeds) features = self.hidden2tag(lstm_out) loss = -self.crf(features, tags, mask=mask) return loss def predict(self, x, mask): embeds = self.embedding(x) lstm_out, _ = self.lstm(embeds) features = self.hidden2tag(lstm_out) return self.crf.decode(features, mask=mask)

训练循环的关键部分：

model = LSTM_CRF(len(word2idx), tag2idx, 50, 300) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) for epoch in range(10): model.train() for batch in train_loader: inputs, tags, masks = batch optimizer.zero_grad() loss = model(inputs, tags, masks) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5) optimizer.step() # 验证 model.eval() with torch.no_grad(): total_loss = 0 for batch in valid_loader: inputs, tags, masks = batch loss = model(inputs, tags, masks) total_loss += loss.item() print(f"Epoch {epoch}, Val Loss: {total_loss/len(valid_loader)}")

8. 实际应用建议

在工业级应用中，我发现以下几点特别重要：

  1. 数据质量比模型更重要：确保标注一致性和覆盖率
  2. 处理未登录词：结合字符级特征或子词单元
  3. 模型部署优化：使用ONNX格式或TorchScript提高推理速度
  4. 持续监控：定期评估模型在生产环境的表现

对于资源受限的场景，可以考虑：

  • 知识蒸馏：用大模型训练小模型
  • 量化：减少模型大小和计算量
  • 剪枝：移除不重要的网络连接

最后要提醒的是，虽然LSTM+CRF已经是一个相对成熟的方案，但在处理超长文本或复杂实体嵌套时仍有局限。这时候可能需要考虑更先进的模型架构，或者将任务拆解为多个子步骤。