【CRF系列】第8篇：CRF与深度学习的融合：BiLSTM-CRF模型

阅读量：

【CRF系列】第8篇：CRF与深度学习的融合：BiLSTM-CRF模型

1. 引言

在之前的文章中对CRF的相关理论体系进行了详细分析

本文旨在介绍双向长短时记忆网络结合条件随机场的模型（BiLSTM-CRF），该架构在序列标注领域具有代表性。它融合了双向长短期记忆网络（BiLSTM）提取上下文特征的能力以及条件随机场（CRF）建立标签依赖关系的能力，在命名实体识别（NER）、词性标注（POS）以及中文分词等多个任务中展现出卓越的效果。

2. 深度学习在序列标注中的优势：BiLSTM

2.1 从RNN到LSTM再到BiLSTM

Recurrent Neural Networks (RNNs) 是专为处理序列数据而设计的神经网络架构。
它们通过引入循环连接来继承前一时间步的状态信息。
然而，在传统的RNN架构中存在梯度消失或爆炸的问题，
这使得它们难以有效建模长期依赖关系。

该方法作为RNN的一种优化方案被称为长短期记忆网络(LSTM)，它通过引入包含三个关键组件的机制——输入门、遗忘门以及输出门——有效缓解了这一挑战。该模型能够有选择地记住或丢弃相关信息，在处理较长序列时表现出更强的能力。

**双向LSTM(BiLSTM)**在功能上进行了扩展，在既过去方向又未来方向上都进行了深度学习。它包含两个相互关联的方向层：

前向LSTM：从左到右处理序列
后向LSTM：从右到左处理序列

最终，两个方向的输出被连接起来，提供包含完整上下文信息的表示。

2.2 BiLSTM的核心优势

在序列标注任务中，BiLSTM相比传统方法具有以下优势：

自动生成特征：无需人工设计特征即可由网络自主提取有效特征表示。
建模长距离依赖关系：能够有效捕捉远距离的空间关联性。
多维上下文分析：系统能够同时融合词语在前后位置上的上下文信息。
深度语义学习：基于预训练词嵌入模型可提取出更为丰富的语义内容。

2.3 BiLSTM的局限性

尽管BiLSTM强大，但它也有明显的局限性：

单独推断 ：BiLSTM在每一个时间段内单独推断标签的概率分布，并未考虑标签间的相互依赖关系。
2. 位置级归一化 ：模型对每一个位置计算出的概率值总和等于1，并未对整个序列进行全局归一化处理。
3. 缺乏硬性规定 ：该模型未能直接编码出明确的标签转移规则。

这些局限性会导致预测结果出现不合法的标签序列，例如：

在NER任务中包含'B-PER I-LOC'标记（一个实体被同时归类为人名和地点）
- 在中文分词过程中遇到'B M B E'情况（这违反了BMES标注规范）

3. BiLSTM-CRF架构：强强联合

3.1 核心思想

BiLSTM-CRF的核心思想是结合两个模型的优势：

BiLSTM：自主提取多样化的相关上下文信息。
- CRF：构建标签间相互依存的关系模型，并使预测结果符合预设的限制条件

这种结合既规避了传统CRF中复杂的人工特征工程设置过程,也解决了纯神经网络模型在处理标签依赖时缺乏有效的连接方式的问题

3.2 模型结构

BiLSTM-CRF模型由以下几个部分组成：

嵌入层(Embedding Layer) ：

输入单词映射为其对应的密集向量表示
这些方法包括Word2Vec、GloVe和FastText等模型
此外还可以考虑引入字符级嵌入或特征嵌入技术

BiLSTM层 ：

复制代码

 * 双向处理序列，捕捉上下文信息
 * 输出每个位置的隐藏状态表示

全连接层 ：

*对应于BiLSTM模型内部隐层状态特征向量与外部输入序列之间的映射关系 * 生成所有位置上所有可能标签对应的发射概率值（Emission Probability Value）

CRF层 ：

管理一个转移分数矩阵(Transition Score Matrix) * 综合考虑发射分数与转移分数以实现全局最优标签序列的解码过程

3.3 数学表示

BiLSTM-CRF模型可以用以下数学形式表示：

发射分数计算 ：

定义输入序列为X=(x₁,x₂,…,xₙ)。
BiLSTM模型生成隐藏状态序列H=(h₁,h₂,…,hₙ)。
全连接层用于计算发射分数E_ij= W·h_i + b（其中i表示位置索引,j表示标签类别）。

序列总分数 ：
对于标签序列 Y = (y₁, y₂, …, yₙ)，其分数为：

复制代码

    Score(X, Y) = ∑ᵢ₌₁ᵏ (发射分数(i, yᵢ) + 转移分数(yᵢ₋₁, yᵢ))

预测概率 ：

复制代码

    P(Y|X) = exp(Score(X, Y)) / Z(X)

其中 Z(X) 是归一化因子：

复制代码

    Z(X) = ∑_Y' exp(Score(X, Y'))

训练目标 ：最大化正确标签序列的对数概率

复制代码

    L = -log P(Y|X) = -Score(X, Y) + log Z(X)

3.4 训练与解码

训练过程 ：

前馈传播过程：通过BiLSTM层进行正向计算，并获取各时间步对应的发射分数
损失评估：借助CRF层对目标序列进行负对数似然损失评估
反向传播过程：求取各层梯度值并完成模型参数优化

解码过程 ：

通过BiLSTM模型计算发射分数
基于转移得分矩阵，并结合Viterbi算法对路径进行求解以识别具有最高得分的标签序列。

4. 深度学习框架中的CRF实现

4.1 TensorFlow中的CRF实现

TensorFlow提供了CRF相关的实现，主要在tensorflow-addons包中：

复制代码

    import tensorflow as tf
    from tensorflow_addons.text import crf
    
    # 定义BiLSTM-CRF模型
    class BiLSTMCRF(tf.keras.Model):
    def __init__(self, vocab_size, num_tags, embedding_dim=128, lstm_units=64):
        super(BiLSTMCRF, self).__init__()
        
        # 嵌入层
        self.embedding = tf.keras.layers.Embedding(
            vocab_size, embedding_dim, mask_zero=True
        )
        
        # BiLSTM层
        self.bilstm = tf.keras.layers.Bidirectional(
            tf.keras.layers.LSTM(
                lstm_units, return_sequences=True, recurrent_dropout=0.1
            )
        )
        
        # 全连接层，输出发射分数
        self.dense = tf.keras.layers.Dense(num_tags)
        
        # CRF层
        self.transition_params = tf.Variable(
            tf.random.uniform(shape=(num_tags, num_tags))
        )
        
        self.num_tags = num_tags
    
    def call(self, inputs, training=None):
        # 计算掩码（处理变长序列）
        mask = tf.math.not_equal(inputs, 0)
        
        # 嵌入层
        x = self.embedding(inputs)
        
        # BiLSTM层
        x = self.bilstm(x, mask=mask)
        
        # 全连接层，输出发射分数
        emissions = self.dense(x)
        
        return emissions, mask
    
    def loss_function(self, emissions, tags, mask):
        log_likelihood, self.transition_params = crf.crf_log_likelihood(
            emissions, tags, sequence_lengths=tf.reduce_sum(tf.cast(mask, tf.int32), axis=-1),
            transition_params=self.transition_params
        )
        return -tf.reduce_mean(log_likelihood)
    
    def predict(self, emissions, mask):
        sequence_lengths = tf.reduce_sum(tf.cast(mask, tf.int32), axis=-1)
        viterbi_sequence, viterbi_score = crf.crf_decode(
            emissions, self.transition_params, sequence_lengths
        )
        return viterbi_sequence
    
    # 使用模型
    model = BiLSTMCRF(vocab_size=10000, num_tags=9)
    optimizer = tf.keras.optimizers.Adam(1e-3)
    
    # 训练步骤
    @tf.function
    def train_step(inputs, tags):
    with tf.GradientTape() as tape:
        emissions, mask = model(inputs)
        loss = model.loss_function(emissions, tags, mask)
    variables = model.trainable_variables
    gradients = tape.gradient(loss, variables)
    optimizer.apply_gradients(zip(gradients, variables))
    return loss
    
    # 测试步骤
    @tf.function
    def test_step(inputs):
    emissions, mask = model(inputs)
    return model.predict(emissions, mask)
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/m3Bz6Zwncx5gWHhXvfSqauGFodb2.png)

4.2 PyTorch中的CRF实现

PyTorch中没有官方的CRF实现，但有几个常用的第三方库，如pytorch-crf：

复制代码

    import torch
    import torch.nn as nn
    from torchcrf import CRF
    
    # 定义BiLSTM-CRF模型
    class BiLSTMCRF(nn.Module):
    def __init__(self, vocab_size, tag_to_ix, embedding_dim=100, hidden_dim=128):
        super(BiLSTMCRF, 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.word_embeds = nn.Embedding(vocab_size, embedding_dim)
        
        # BiLSTM层
        self.lstm = nn.LSTM(embedding_dim, hidden_dim // 2,
                            num_layers=1, bidirectional=True)
        
        # 全连接层，输出发射分数
        self.hidden2tag = nn.Linear(hidden_dim, self.tagset_size)
        
        # CRF层
        self.crf = CRF(self.tagset_size, batch_first=True)
    
    def _get_lstm_features(self, sentence):
        embeds = self.word_embeds(sentence)
        lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))
        lstm_out = lstm_out.view(len(sentence), self.hidden_dim)
        lstm_feats = self.hidden2tag(lstm_out)
        return lstm_feats
    
    def forward(self, sentence, tags=None, mask=None):
        emissions = self._get_lstm_features(sentence)
        
        if tags is not None:
            # 训练模式，返回负对数似然
            return -self.crf(emissions.unsqueeze(0), tags.unsqueeze(0), mask.unsqueeze(0) if mask is not None else None)
        else:
            # 测试模式，返回最优标签序列
            return self.crf.decode(emissions.unsqueeze(0))
    
    # 使用模型
    def prepare_sequence(seq, to_ix):
    idxs = [to_ix.get(w, to_ix["<UNK>"]) for w in seq]
    return torch.tensor(idxs, dtype=torch.long)
    
    # 定义训练函数
    def train(model, train_data, optimizer, epochs=10):
    for epoch in range(epochs):
        total_loss = 0
        for sentence, tags in train_data:
            # 清除梯度
            model.zero_grad()
            
            # 准备输入
            sentence_in = prepare_sequence(sentence, word_to_ix)
            targets = prepare_sequence(tags, tag_to_ix)
            
            # 计算损失并更新参数
            loss = model(sentence_in, targets)
            total_loss += loss.item()
            
            loss.backward()
            optimizer.step()
        
        print(f"Epoch {epoch+1}, loss: {total_loss}")
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/0q6E2IaPXfKNSJOHUp9uZ7t5QD1l.png)

5. BiLSTM-CRF的优势总结

BiLSTM-CRF模型相比纯BiLSTM或传统CRF有以下显著优势：

无需人工设计特征函数：BiLSTM能够自动生成有效的特征表示。
2. 全连接训练策略：整个模型实现统一优化过程。
3. 全局最优预测：CRF层通过综合考虑序列标签间的相互关系实现整体最优解码。
4. 语义约束建模：该方法可有效避免输出不合理的标签序列。
5. 显著的性能优势：在多数序列标注任务中采用BiLSTM-CRF架构可获得显著提升的效果。

以下是一些具体任务上的改进效果对比：

任务	模型	F1分数
英文NER (CoNLL-2003)	BiLSTM	88.5%
英文NER (CoNLL-2003)	BiLSTM-CRF	90.9%
中文分词 (MSRA)	BiLSTM	95.2%
中文分词 (MSRA)	BiLSTM-CRF	97.4%

注：以上数据仅为说明性示例，实际效果会因具体实现和数据集而异。

6. 实际应用示例：命名实体识别

以下是一个完整的BiLSTM-CRF用于命名实体识别的示例：

复制代码

    import numpy as np
    import tensorflow as tf
    from tensorflow_addons.text import crf
    from tensorflow.keras.preprocessing.sequence import pad_sequences
    from sklearn.model_selection import train_test_split
    
    # 示例数据准备（在实际应用中应使用真实数据集）
    # 格式：[(句子, 标签), ...]
    data = [
    (["Obama", "was", "born", "in", "Hawaii", "."], ["B-PER", "O", "O", "O", "B-LOC", "O"]),
    (["Microsoft", "was", "founded", "by", "Bill", "Gates", "."], ["B-ORG", "O", "O", "O", "B-PER", "I-PER", "O"])
    ]
    
    # 创建词汇表和标签映射
    words = set()
    tags = set()
    for sentence, sentence_tags in data:
    for word in sentence:
        words.add(word.lower())
    for tag in sentence_tags:
        tags.add(tag)
    
    word_to_idx = {word: i+1 for i, word in enumerate(words)}  # 0留给padding
    word_to_idx["<UNK>"] = len(word_to_idx) + 1
    tag_to_idx = {tag: i for i, tag in enumerate(tags)}
    idx_to_tag = {i: tag for tag, i in tag_to_idx.items()}
    
    # 准备训练数据
    X = [[word_to_idx.get(word.lower(), word_to_idx["<UNK>"]) for word in sentence] for sentence, _ in data]
    y = [[tag_to_idx[tag] for tag in sentence_tags] for _, sentence_tags in data]
    
    # 填充序列
    X_padded = pad_sequences(X, padding="post")
    y_padded = pad_sequences(y, padding="post")
    
    # 创建掩码
    mask = (X_padded != 0)
    
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test, mask_train, mask_test = train_test_split(
    X_padded, y_padded, mask, test_size=0.2, random_state=42
    )
    
    # 定义模型
    class BiLSTMCRF(tf.keras.Model):
    def __init__(self, vocab_size, num_tags, embedding_dim=128, lstm_units=64):
        super(BiLSTMCRF, self).__init__()
        self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim, mask_zero=True)
        self.bilstm = tf.keras.layers.Bidirectional(
            tf.keras.layers.LSTM(lstm_units, return_sequences=True)
        )
        self.dense = tf.keras.layers.Dense(num_tags)
        self.transition_params = tf.Variable(
            tf.random.uniform(shape=(num_tags, num_tags))
        )
    
    def call(self, inputs, training=None):
        mask = tf.math.not_equal(inputs, 0)
        x = self.embedding(inputs)
        x = self.bilstm(x, mask=mask)
        emissions = self.dense(x)
        return emissions, mask
    
    def loss_function(self, emissions, tags, mask):
        log_likelihood, self.transition_params = crf.crf_log_likelihood(
            emissions, tags, sequence_lengths=tf.reduce_sum(tf.cast(mask, tf.int32), axis=-1),
            transition_params=self.transition_params
        )
        return -tf.reduce_mean(log_likelihood)
    
    def predict(self, emissions, mask):
        sequence_lengths = tf.reduce_sum(tf.cast(mask, tf.int32), axis=-1)
        viterbi_sequence, viterbi_score = crf.crf_decode(
            emissions, self.transition_params, sequence_lengths
        )
        return viterbi_sequence
    
    # 初始化模型和优化器
    vocab_size = len(word_to_idx) + 1  # +1 for padding
    num_tags = len(tag_to_idx)
    model = BiLSTMCRF(vocab_size, num_tags)
    optimizer = tf.keras.optimizers.Adam(1e-3)
    
    # 训练函数
    @tf.function
    def train_step(inputs, tags, mask):
    with tf.GradientTape() as tape:
        emissions, mask = model(inputs)
        loss = model.loss_function(emissions, tags, mask)
    variables = model.trainable_variables
    gradients = tape.gradient(loss, variables)
    optimizer.apply_gradients(zip(gradients, variables))
    return loss
    
    # 训练模型
    epochs = 10
    batch_size = 2  # 在实际应用中应使用更大的批量
    
    for epoch in range(epochs):
    total_loss = 0
    for i in range(0, len(X_train), batch_size):
        batch_X = X_train[i:i+batch_size]
        batch_y = y_train[i:i+batch_size]
        batch_mask = mask_train[i:i+batch_size]
        loss = train_step(batch_X, batch_y, batch_mask)
        total_loss += loss
    print(f"Epoch {epoch+1}, Loss: {total_loss}")
    
    # 评估模型
    def evaluate(X, y, mask):
    emissions, mask = model(X)
    pred = model.predict(emissions, mask)
    
    # 计算准确率（仅考虑非padding部分）
    mask_flat = mask.numpy().flatten()
    pred_flat = pred.numpy().flatten()
    y_flat = y.flatten()
    
    correct = (pred_flat == y_flat) & mask_flat
    accuracy = correct.sum() / mask_flat.sum()
    
    return accuracy
    
    accuracy = evaluate(X_test, y_test, mask_test)
    print(f"Test Accuracy: {accuracy:.4f}")
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/SkZmpze0JLa3HiF7r6lV9wAouCs4.png)

7. 总结与展望

本文对BiLSTM-CRF模型进行了深入阐述，并详细探讨了该模型如何通过深度学习技术实现自动生成特征的能力以及通过条件随机场方法实现结构化输出的能力。该模型已被广泛认可为序列标注任务的主要应用方案之一。

我们学习了：

探讨BiLSTM机制及其在上下文信息处理方面的特点与挑战
分析BiLSTM-CRF模型的结构组成及其运行机制
阐述在主流深度学习框架中实现BiLSTM-CRF技术的具体方法
探讨该模型在实际应用场景中的应用价值及其性能表现

CRF系列

改写内容

8. 思考题

在BiLSTM-CRF模型中,'发射概率'相当于传统CRF模型中的哪一部分？而'转移概率'则对应的又是什么呢？

在许多序列标注任务中为何仅需加入CRF层即可显著提高BiLSTM的效果？我们能否深入探讨何时CRF层的作用更加突出？

全部评论 (0)

还没有任何评论哟~

【CRF系列】第8篇：CRF与深度学习的融合：BiLSTM-CRF模型

【CRF系列】第8篇：CRF与深度学习的融合：BiLSTMCRF模型 1\.引言在前面的文章中，我们已经深入探讨了CRF的理论基础和实际应用。传统CRF模型的一个关键挑战是需要精心设计特征函数，这不...

CRF以及BiLSTM+CRF

BiLSTM+CRF 现在比较流行的是bilstm+crf，即在bilstm后面接了crf层经过bilstm得到隐状态序列h1,h2,...,hn\inR^nm 接入一个线性层，转换隐状态序列的维度...

论文学习9-Bidirectional LSTM-CRF Models for Sequence Tagging（LSTM，BILSTM,LSTM-CRF,BILSTM-CRF

文章目录 1.Introduction 2model 2.1LSTM 2.2BILSTM BPTT 2.3CRF 2.4LSTMCRF 参考文献本篇论文介绍了LSTM网络、BILSTM网络、CRF网...

Bilstm+crf中的crf详解

本文是对bilstm+crf模型中的crf进行讲解，并不是完整的条件随机场的讲解。如果对命名实体识别还不清楚的同学，可以先看这篇文章。代码在这里。模型如下图所示。我们已知lstm的输出就是每个字...

HMM->MEMM->CRF以及BiLSTM+CRF中的CRF层

参考： 1.B站《机器学习白板推导系列（十七）》<https://www.bilibili.com/video/av34444816/ 2.<https://zhuanlan.zhihu.com/p/...

序列标注：BiLSTM-CRF模型

概述对于序列标注问题，目前BiLSTMCRF模型是目前使用比较流行的方法。本文以NeuralArchitecturesforNamedEntityRecognition为例，讲解BiLSTMCRF模...

CRF原理介绍（以BILSTM-CRF模型为例）

文章目录 1\.BiLSTMCRF命名实体识别概要 1.1模型介绍 1.2CRF在模型中的作用 2\.CRF层详解 2.1发射矩阵emission矩阵 2.2转移矩阵（Transition得分） 2....

BiLSTM-CRF中CRF层的作用

1、先验知识:命名实体识别或序列标注，基本掌握LSTM、CRF的基本概念。也可参考： LSTM CRF 2、基本概念与假设：假设我们的数据集中有两类实体——人名和地名，与之相对应在我们的训练数据集中...

【CRF系列】第5篇：CRF的学习：参数估计与优化算法

【CRF系列】第5篇：CRF的学习：参数估计与优化算法 1\.引言在之前的文章中，我们了解了CRF的基本概念、理论基础、数学形式，以及特征函数的设计。现在，我们面临着一个关键问题：如何确定这些特征函...

deep learning 08. biLSTM+crf以及cnn+biLSTM+crf

开始的话：从基础做起，不断学习，坚持不懈，加油。一位爱生活爱技术来自火星的程序汪画了两个模型的graph。方便后续回顾网络结构，加深自己的理解。 biLSTM\+CRF cnn\+biLSTM\...

是否确定退出登录?

【CRF系列】第8篇：CRF与深度学习的融合：BiLSTM-CRF模型