Mindspore框架CRF条件随机场概率图模型实现文本序列命名实体标注|（一）序列标注与条件随机场的关系
Mindspore框架CRF条件随机场概率图模型实现文本序列命名实体标注|（二）CRF模型构建
Mindspore框架CRF条件随机场概率图模型实现文本序列命名实体标注|（三）双向LSTM+CRF模型构建实现

---

Mindspore框架CRF条件随机场概率图模型实现文本序列命名实体标注|（三）双向LSTM+CRF模型构建

一、双向LSTM+CRF

BI-LSTM-CRF模型：优势在于它结合了双向LSTM的能力来捕获长距离的双向上下文依赖性，并通过CRF层来精确地建模标签之间的约束关系（CRF层能够确保识别出的实体标签在整个序列中保持一致性），从而在复杂的序列标注任务中提供了显著的性能提升。
在实现CRF后，我们设计一个双向LSTM+CRF的模型来进行命名实体识别任务的训练。
模型结构如下：

nn.Embedding -> nn.LSTM -> nn.Dense -> CRF

其中LSTM提取序列特征，经过Dense层变换获得发射概率矩阵，最后送入CRF层。具体实现如下：

class BiLSTM_CRF(nn.Cell):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_tags, padding_idx=0):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=padding_idx)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim // 2, bidirectional=True, batch_first=True)
        self.hidden2tag = nn.Dense(hidden_dim, num_tags, 'he_uniform')
        self.crf = CRF(num_tags, batch_first=True)

    def construct(self, inputs, seq_length, tags=None):
        embeds = self.embedding(inputs)
        outputs, _ = self.lstm(embeds, seq_length=seq_length)
        feats = self.hidden2tag(outputs)

        crf_outs = self.crf(feats, tags, seq_length)
        return crf_outs

二、构造词表和标签表

构建一个简易训练集：

embedding_dim = 16
hidden_dim = 32

training_data = [(
    "清 华 大 学 坐 落 于 首 都 北 京".split(),
    "B I I I O O O O O B I".split()
), (
    "重 庆 是 一 个 魔 幻 城 市".split(),
    "B I O O O O O O O".split()
),(
    "北 京 大 学 坐 落 于 首 都 北 京".split(),
    "B I I I O O O O O B I".split()
), (
    "南 京 大 学 坐 落 于 故 都 南 京".split(),
    "B I I I O O O O O B I".split()
)]

word_to_idx = {}
word_to_idx['<pad>'] = 0
for sentence, tags in training_data:
    for word in sentence:
        if word not in word_to_idx:
            word_to_idx[word] = len(word_to_idx)

tag_to_idx = {"B": 0, "I": 1, "O": 2}  # 定义标签-序列

预测时使用：序列转标签

idx_to_tag = {idx: tag for tag, idx in tag_to_idx.items()}

def sequence_to_tag(sequences, idx_to_tag):
    outputs = []
    for seq in sequences:
        outputs.append([idx_to_tag[i] for i in seq])
    return outputs

测试输出len(word_to_idx)结果：

将生成的数据打包成Batch，按照序列最大长度，对长度不足的序列进行填充，分别返回输入序列、输出标签和序列长度构成的Tensor。

def prepare_sequence(seqs, word_to_idx, tag_to_idx):
    seq_outputs, label_outputs, seq_length = [], [], []
    max_len = max([len(i[0]) for i in seqs])

    for seq, tag in seqs:
        seq_length.append(len(seq))
        idxs = [word_to_idx[w] for w in seq]
        labels = [tag_to_idx[t] for t in tag]
        idxs.extend([word_to_idx['<pad>'] for i in range(max_len - len(seq))])
        labels.extend([tag_to_idx['O'] for i in range(max_len - len(seq))])
        seq_outputs.append(idxs)
        label_outputs.append(labels)

    return ms.Tensor(seq_outputs, ms.int64), \
            ms.Tensor(label_outputs, ms.int64), \
            ms.Tensor(seq_length, ms.int64)

data, label, seq_length = prepare_sequence(training_data, word_to_idx, tag_to_idx)
print(data.shape, label.shape, seq_length.shape)

((4, 11), (4, 11), (4,))

三、训练双向LSTM+CRF模型

模型初始化：

model = BiLSTM_CRF(len(word_to_idx), embedding_dim, hidden_dim, len(tag_to_idx))
optimizer = nn.SGD(model.trainable_params(), learning_rate=0.01, weight_decay=1e-4)
grad_fn = ms.value_and_grad(model, None, optimizer.parameters)

def train_step(data, seq_length, label):
    loss, grads = grad_fn(data, seq_length, label)
    optimizer(grads)
    return loss

训练模型：

from tqdm import tqdm

steps = 500
with tqdm(total=steps) as t:
    for i in range(steps):
        loss = train_step(data, seq_length, label)
        t.set_postfix(loss=loss)
        t.update(1)

四、模型预测

score, history = model(data, seq_length)  
# 打印实体命名预测结果
res = sequence_to_tag(predict, idx_to_tag)
print(res)

预测：

输出：