昇思25天学习打卡营第24天 | LSTM+CRF序列标注

且ゞ行

于 2024-07-22 21:49:21 发布

阅读量322

点赞数 16

文章标签：学习 lstm 人工智能

本文链接：https://blog.csdn.net/qq_59313474/article/details/140616949

版权

今天是参加昇思学习打卡营的第24天，学习内容是LSTM+CRF序列标注。

以下是内容关键点概要:

序列标注概述：

序列标注是为输入序列中的每个Token分配标签的过程，常用于信息提取任务，如分词、词性标注和命名实体识别（NER）。
以NER为例，使用“BIOE”标注方法，实体的开头用B标记，其他部分用I标记，非实体用O标记。

条件随机场（CRF）：

序列标注需要考虑Token之间的依赖关系，CRF是一种适合此类场景的概率图模型。
线性链CRF用于计算序列中每个Token的标签，并捕获相邻标签之间的关系。

CRF的数学定义：

定义了发射概率函数和转移概率函数，通过Score计算公式来评估序列标注的可能性。
使用动态规划算法高效计算Normalizer，即所有可能输出序列的Score的对数指数和。

Viterbi算法：

用于解码CRF层，求解序列最优路径，考虑所有可能的预测序列得分。

CRF层实现：

实现了CRF层的前向训练部分，包括Score和Normalizer的计算。
实现了Viterbi算法的解码部分，用于预测最优的标签序列。

BiLSTM+CRF模型：

设计了一个双向LSTM+CRF模型进行命名实体识别任务的训练。
LSTM用于提取序列特征，Dense层用于变换发射概率矩阵，最后送入CRF层。

模型训练：

实例化BiLSTM_CRF模型，选择优化器，并将模型和优化器送入训练循环。
使用准备的数据集进行训练，并对模型效果进行观察。

结果展示：

使用训练后的模型预测序列标注，并展示预测结果。

概述

序列标注指给定输入序列，给序列中每个Token进行标注标签的过程。序列标注问题通常用于从文本中进行信息抽取，包括分词(Word Segmentation)、词性标注(Position Tagging)、命名实体识别(Named Entity Recognition, NER)等。以命名实体识别为例：

输入序列	清	华	大	学	座	落	于	首	都	北	京
输出标注	B	I	I	I	O	O	O	O	O	B	I

如上表所示，清华大学 和 北京是地名，需要将其识别，我们对每个输入的单词预测其标签，最后根据标签来识别实体。

这里使用了一种常见的命名实体识别的标注方法——“BIOE”标注，将一个实体(Entity)的开头标注为B，其他部分标注为I，非实体标注为O。

条件随机场(Conditional Random Field, CRF)

从上文的举例可以看到，对序列进行标注，实际上是对序列中每个Token进行标签预测，可以直接视作简单的多分类问题。但是序列标注不仅仅需要对单个Token进行分类预测，同时相邻Token直接有关联关系。以清华大学一词为例:

输入序列	清	华	大	学
输出标注	B	I	I	I	√
输出标注	O	I	I	I	×

如上表所示，正确的实体中包含的4个Token有依赖关系，I前必须是B或I，而错误输出结果将清字标注为O，违背了这一依赖。将命名实体识别视为多分类问题，则每个词的预测概率都是独立的，易产生类似的问题，因此需要引入一种能够学习到此种关联关系的算法来保证预测结果的正确性。而条件随机场是适合此类场景的一种概率图模型。下面对条件随机场的定义和参数化形式进行简析。

考虑到序列标注问题的线性序列特点，本节所述的条件随机场特指线性链条件随机场(Linear Chain CRF)

设𝑥={𝑥0,...,𝑥𝑛}𝑥={𝑥0,...,𝑥𝑛}为输入序列，𝑦={𝑦0,...,𝑦𝑛}，𝑦∈𝑌𝑦={𝑦0,...,𝑦𝑛}，𝑦∈𝑌为输出的标注序列，其中𝑛𝑛为序列的最大长度，𝑌𝑌表示𝑥𝑥对应的所有可能的输出序列集合。则输出序列𝑦𝑦的概率为：

𝑃(𝑦|𝑥)=exp(Score(𝑥,𝑦))∑𝑦′∈𝑌exp(Score(𝑥,𝑦′))(1)𝑃(𝑦|𝑥)=exp⁡(Score(𝑥,𝑦))∑𝑦′∈𝑌exp⁡(Score(𝑥,𝑦′))(1)

设𝑥𝑖𝑥𝑖, 𝑦𝑖𝑦𝑖为序列的第𝑖𝑖个Token和对应的标签，则ScoreScore需要能够在计算𝑥𝑖𝑥𝑖和𝑦𝑖𝑦𝑖的映射的同时，捕获相邻标签𝑦𝑖−1𝑦𝑖−1和𝑦𝑖𝑦𝑖之间的关系，因此我们定义两个概率函数：

发射概率函数𝜓EMIT𝜓EMIT：表示𝑥𝑖→𝑦𝑖𝑥𝑖→𝑦𝑖的概率。
转移概率函数𝜓TRANS𝜓TRANS：表示𝑦𝑖−1→𝑦𝑖𝑦𝑖−1→𝑦𝑖的概率。

则可以得到ScoreScore的计算公式：

Score(𝑥,𝑦)=∑𝑖log𝜓EMIT(𝑥𝑖→𝑦𝑖)+log𝜓TRANS(𝑦𝑖−1→𝑦𝑖)(2)Score(𝑥,𝑦)=∑𝑖log⁡𝜓EMIT(𝑥𝑖→𝑦𝑖)+log⁡𝜓TRANS(𝑦𝑖−1→𝑦𝑖)(2)

设标签集合为𝑇𝑇，构造大小为|𝑇|𝑥|𝑇||𝑇|𝑥|𝑇|的矩阵𝐏P，用于存储标签间的转移概率；由编码层(可以为Dense、LSTM等)输出的隐状态ℎℎ可以直接视作发射概率，此时ScoreScore的计算公式可以转化为：

Score(𝑥,𝑦)=∑𝑖ℎ𝑖[𝑦𝑖]+𝐏𝑦𝑖−1,𝑦𝑖(3)Score(𝑥,𝑦)=∑𝑖ℎ𝑖[𝑦𝑖]+P𝑦𝑖−1,𝑦𝑖(3)

完整的CRF完整推导可参考Log-Linear Models, MEMMs, and CRFs

接下来我们根据上述公式，使用MindSpore来实现CRF的参数化形式。首先实现CRF层的前向训练部分，将CRF和损失函数做合并，选择分类问题常用的负对数似然函数(Negative Log Likelihood, NLL)，则有：

Loss=−𝑙𝑜𝑔(𝑃(𝑦|𝑥))(4)Loss=−𝑙𝑜𝑔(𝑃(𝑦|𝑥))(4)

由公式(1)(1)可得，

Loss=−𝑙𝑜𝑔(exp(Score(𝑥,𝑦))∑𝑦′∈𝑌exp(Score(𝑥,𝑦′)))(5)Loss=−𝑙𝑜𝑔(exp⁡(Score(𝑥,𝑦))∑𝑦′∈𝑌exp⁡(Score(𝑥,𝑦′)))(5)

=𝑙𝑜𝑔(∑𝑦′∈𝑌exp(Score(𝑥,𝑦′))−Score(𝑥,𝑦)=𝑙𝑜𝑔(∑𝑦′∈𝑌exp⁡(Score(𝑥,𝑦′))−Score(𝑥,𝑦)

根据公式(5)(5)，我们称被减数为Normalizer，减数为Score，分别实现后相减得到最终Loss。

Score计算

首先根据公式(3)(3)计算正确标签序列所对应的得分，这里需要注意，除了转移概率矩阵𝐏P外，还需要维护两个大小为|𝑇||𝑇|的向量，分别作为序列开始和结束时的转移概率。同时我们引入了一个掩码矩阵𝑚𝑎𝑠𝑘𝑚𝑎𝑠𝑘，将多个序列打包为一个Batch时填充的值忽略，使得ScoreScore计算仅包含有效的Token。

import mindspore.numpy as mnp

def compute_score(emissions, tags, seq_ends, mask, trans, start_trans, end_trans):
    """
    计算给定标签序列的得分。
    
    参数:
    - emissions: 发射概率矩阵，形状为 (seq_length, batch_size, num_tags)
    - tags: 真实标签序列，形状为 (seq_length, batch_size)
    - seq_ends: 序列结束的索引，形状为 (batch_size,)
    - mask: 掩码矩阵，用于忽略填充的Token，形状为 (seq_length, batch_size)
    - trans: 转移概率矩阵，形状为 (num_tags, num_tags)
    - start_trans: 初始转移概率向量，形状为 (num_tags,)
    - end_trans: 结束转移概率向量，形状为 (num_tags,)
    
    返回:
    - score: 给定标签序列的得分，形状为 (batch_size,)
    """

    # 获取标签序列的长度和批量大小
    seq_length, batch_size = tags.shape
    
    # 将掩码矩阵的数据类型转换为与发射概率矩阵一致
    mask = mask.astype(emissions.dtype)

    # 初始化得分为初始转移概率
    # 形状: (batch_size,)
    score = start_trans[tags[0]]
    
    # 累加第一次发射概率
    # 形状: (batch_size,)
    score += emissions[0, mnp.arange(batch_size), tags[0]]

    # 遍历序列的每个Token，计算转移和发射概率的得分
    for i in range(1, seq_length):
        # 计算标签由i-1转移至i的转移概率得分（仅当mask == 1时有效）
        # 形状: (batch_size,)
        score += trans[tags[i - 1], tags[i]] * mask[i]
        
        # 累加预测tags[i]的发射概率得分（仅当mask == 1时有效）
        # 形状: (batch_size,)
        score += emissions[i, mnp.arange(batch_size), tags[i]] * mask[i]

    # 计算结束转移概率得分
    # 形状: (batch_size,)
    last_tags = tags[seq_ends, mnp.arange(batch_size)]
    # 累加结束转移概率得分
    # 形状: (batch_size,)
    score += end_trans[last_tags]

    return score

Normalizer计算

根据公式(5)(5)，Normalizer是𝑥𝑥对应的所有可能的输出序列的Score的对数指数和(Log-Sum-Exp)。此时如果按穷举法进行计算，则需要将每个可能的输出序列Score都计算一遍，共有|𝑇|𝑛|𝑇|𝑛个结果。这里我们采用动态规划算法，通过复用计算结果来提高效率。

假设需要计算从第00至第𝑖𝑖个Token所有可能的输出序列得分Score𝑖Score𝑖，则可以先计算出从第00至第𝑖−1𝑖−1个Token所有可能的输出序列得分Score𝑖−1Score𝑖−1。因此，Normalizer可以改写为以下形式：

𝑙𝑜𝑔(∑𝑦′0,𝑖∈𝑌exp(Score𝑖))=𝑙𝑜𝑔(∑𝑦′0,𝑖−1∈𝑌exp(Score𝑖−1+ℎ𝑖+𝐏))(6)𝑙𝑜𝑔(∑𝑦0,𝑖′∈𝑌exp⁡(Score𝑖))=𝑙𝑜𝑔(∑𝑦0,𝑖−1′∈𝑌exp⁡(Score𝑖−1+ℎ𝑖+P))(6)

其中ℎ𝑖ℎ𝑖为第𝑖𝑖个Token的发射概率，𝐏P是转移矩阵。由于发射概率矩阵ℎℎ和转移概率矩阵𝐏P独立于𝑦𝑦的序列路径计算，可以将其提出，可得：

𝑙𝑜𝑔(∑𝑦′0,𝑖∈𝑌exp(Score𝑖))=𝑙𝑜𝑔(∑𝑦′0,𝑖−1∈𝑌exp(Score𝑖−1))+ℎ𝑖+𝐏(7)𝑙𝑜𝑔(∑𝑦0,𝑖′∈𝑌exp⁡(Score𝑖))=𝑙𝑜𝑔(∑𝑦0,𝑖−1′∈𝑌exp⁡(Score𝑖−1))+ℎ𝑖+P(7)

根据公式(7)，Normalizer的实现如下：

import mindspore.ops as ops
import mindspore.numpy as mnp

def compute_normalizer(emissions, mask, trans, start_trans, end_trans):
    """
    计算规范化项，即所有可能标签序列的得分的对数和。
    
    参数:
    - emissions: 发射概率矩阵，形状为 (seq_length, batch_size, num_tags)
    - mask: 掩码矩阵，用于忽略填充的Token，形状为 (seq_length, batch_size)
    - trans: 转移概率矩阵，形状为 (num_tags, num_tags)
    - start_trans: 初始转移概率向量，形状为 (num_tags,)
    - end_trans: 结束转移概率向量，形状为 (num_tags,)
    
    返回:
    - normalizer: 规范化项的对数和，形状为 (batch_size,)
    """

    seq_length = emissions.shape[0]

    # 初始化得分为初始转移概率，并加上第一次发射概率
    # 形状: (batch_size, num_tags)
    score = start_trans + emissions[0]

    for i in range(1, seq_length):
        # 扩展score的维度用于总score的计算
        # 形状: (batch_size, num_tags, 1)
        broadcast_score = score.expand_dims(2)

        # 扩展emission的维度用于总score的计算
        # 形状: (batch_size, 1, num_tags)
        broadcast_emissions = emissions[i].expand_dims(1)

        # 根据公式(7)，计算score_i
        # 此时broadcast_score是由第0个到当前Token所有可能路径
        # 对应score的log_sum_exp
        # 形状: (batch_size, num_tags, num_tags)
        next_score = broadcast_score + trans + broadcast_emissions

        # 对score_i做log_sum_exp运算，用于下一个Token的score计算
        # 形状: (batch_size, num_tags)
        next_score = ops.logsumexp(next_score, axis=1)

        # 当mask == 1时，score才会变化
        # 形状: (batch_size, num_tags)
        score = mnp.where(mask[i].expand_dims(1), next_score, score)

    # 最后加结束转移概率
    # 形状: (batch_size, num_tags)
    score += end_trans
    # 对所有可能的路径得分求log_sum_exp
    # 形状: (batch_size,)
    return ops.logsumexp(score, axis=1)

Viterbi算法

在完成前向训练部分后，需要实现解码部分。这里我们选择适合求解序列最优路径的Viterbi算法。与计算Normalizer类似，使用动态规划求解所有可能的预测序列得分。不同的是在解码时同时需要将第𝑖𝑖个Token对应的score取值最大的标签保存，供后续使用Viterbi算法求解最优预测序列使用。

取得最大概率得分ScoreScore，以及每个Token对应的标签历史HistoryHistory后，根据Viterbi算法可以得到公式：

𝑃0,𝑖=𝑚𝑎𝑥(𝑃0,𝑖−1)+𝑃𝑖−1,𝑖𝑃0,𝑖=𝑚𝑎𝑥(𝑃0,𝑖−1)+𝑃𝑖−1,𝑖

从第0个至第𝑖𝑖个Token对应概率最大的序列，只需要考虑从第0个至第𝑖−1𝑖−1个Token对应概率最大的序列，以及从第𝑖𝑖个至第𝑖−1𝑖−1个概率最大的标签即可。因此我们逆序求解每一个概率最大的标签，构成最佳的预测序列。

由于静态图语法限制，我们将Viterbi算法求解最佳预测序列的部分作为后处理函数，不纳入后续CRF层的实现。

def post_decode(score, history, seq_length):
    """
    使用Score和History计算最佳预测序列。
    
    参数:
    - score: 最大概率得分
    - history: 每个Token对应最大得分标签的索引历史
    - seq_length: 序列的实际长度
    
    返回:
    - best_tags_list: 最佳预测标签序列列表
    """

    batch_size = seq_length.shape[0]
    seq_ends = seq_length - 1
    # 初始化最佳标签列表
    best_tags_list = []

    # 依次对一个Batch中每个样例进行解码
    for idx in range(batch_size):
        # 查找使最后一个Token对应的预测概率最大的标签
        best_last_tag = score[idx].argmax(axis=0)
        best_tags = [int(best_last_tag.asnumpy())]

        # 逆序遍历历史记录，查找每个Token对应的预测概率最大的标签
        for hist in reversed(history[:seq_ends[idx]]):
            best_last_tag = hist[idx][best_tags[-1]]
            best_tags.append(int(best_last_tag.asnumpy()))

        # 将逆序求解的序列标签重置为正序
        best_tags.reverse()
        best_tags_list.append(best_tags)

    return best_tags_list

CRF层

完成上述前向训练和解码部分的代码后，将其组装完整的CRF层。考虑到输入序列可能存在Padding的情况，CRF的输入需要考虑输入序列的真实长度，因此除发射矩阵和标签外，加入seq_length参数传入序列Padding前的长度，并实现生成mask矩阵的sequence_mask方法。

综合上述代码，使用nn.Cell进行封装，最后实现完整的CRF层如下：

import mindspore as ms
import mindspore.nn as nn
import mindspore.ops as ops
import mindspore.numpy as mnp
from mindspore.common.initializer import initializer, Uniform

def sequence_mask(seq_length, max_length, batch_first=False):
    """
    根据序列实际长度和最大长度生成mask矩阵。
    
    参数:
    - seq_length: 序列的实际长度
    - max_length: 序列的最大长度
    - batch_first: 是否将批次维度放在首位
    
    返回:
    - mask: 掩码矩阵，用于忽略填充的Token
    """
    range_vector = mnp.arange(0, max_length, 1, seq_length.dtype)
    result = range_vector < seq_length.view(seq_length.shape + (1,))
    if batch_first:
        return result.astype(ms.int64)
    return result.astype(ms.int64).swapaxes(0, 1)

class CRF(nn.Cell):
    def __init__(self, num_tags: int, batch_first: bool = False, reduction: str = 'sum') -> None:
        """
        初始化CRF层。
        
        参数:
        - num_tags: 标签的数量
        - batch_first: 是否将批次维度放在首位
        - reduction: 损失函数的缩减方式，可以是 'none', 'sum', 'mean', 'token_mean'
        """
        if num_tags <= 0:
            raise ValueError(f'invalid number of tags: {num_tags}')
        super().__init__()
        if reduction not in ('none', 'sum', 'mean', 'token_mean'):
            raise ValueError(f'invalid reduction: {reduction}')
        self.num_tags = num_tags
        self.batch_first = batch_first
        self.reduction = reduction
        # 初始化开始和结束转移概率
        self.start_transitions = ms.Parameter(initializer(Uniform(0.1), (num_tags,)), name='start_transitions')
        self.end_transitions = ms.Parameter(initializer(Uniform(0.1), (num_tags,)), name='end_transitions')
        # 初始化转移概率矩阵
        self.transitions = ms.Parameter(initializer(Uniform(0.1), (num_tags, num_tags)), name='transitions')

    def construct(self, emissions, tags=None, seq_length=None):
        """
        前向传播函数。
        
        参数:
        - emissions: 发射概率矩阵
        - tags: 真实标签序列
        - seq_length: 序列的实际长度
        
        返回:
        - 如果tags为None，则返回解码结果；否则返回损失函数的值。
        """
        if tags is None:
            return self._decode(emissions, seq_length)
        return self._forward(emissions, tags, seq_length)

    def _forward(self, emissions, tags=None, seq_length=None):
        """
        计算损失函数的前向传播。
        
        参数:
        - emissions: 发射概率矩阵
        - tags: 真实标签序列
        - seq_length: 序列的实际长度
        
        返回:
        - 损失函数的值
        """
        if self.batch_first:
            batch_size, max_length = tags.shape
            emissions = emissions.swapaxes(0, 1)
            tags = tags.swapaxes(0, 1)
        else:
            max_length, batch_size = tags.shape

        if seq_length is None:
            seq_length = mnp.full((batch_size,), max_length, ms.int64)

        mask = sequence_mask(seq_length, max_length)

        # 计算分子（正确标签序列的得分）
        numerator = compute_score(emissions, tags, seq_length-1, mask, self.transitions, self.start_transitions, self.end_transitions)
        # 计算分母（所有可能标签序列的得分的对数和）
        denominator = compute_normalizer(emissions, mask, self.transitions, self.start_transitions, self.end_transitions)
        # 计算负对数似然损失
        llh = denominator - numerator

        if self.reduction == 'none':
            return llh
        if self.reduction == 'sum':
            return llh.sum()
        if self.reduction == 'mean':
            return llh.mean()
        return llh.sum() / mask.astype(emissions.dtype).sum()

    def _decode(self, emissions, seq_length=None):
        """
        解码函数，使用Viterbi算法找到最优的标签序列。
        
        参数:
        - emissions: 发射概率矩阵
        - seq_length: 序列的实际长度
        
        返回:
        - 最优标签序列的得分和路径
        """
        if self.batch_first:
            batch_size, max_length = emissions.shape[:2]
            emissions = emissions.swapaxes(0, 1)
        else:
            batch_size, max_length = emissions.shape[:2]

        if seq_length is None:
            seq_length = mnp.full((batch_size,), max_length, ms.int64)

        mask = sequence_mask(seq_length, max_length)

        return viterbi_decode(emissions, mask, self.transitions, self.start_transitions, self.end_transitions)

BiLSTM+CRF模型

在实现CRF后，我们设计一个双向LSTM+CRF的模型来进行命名实体识别任务的训练。模型结构如下：

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

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

import mindspore.nn as nn
import mindspore.ops as ops
import mindspore.numpy as mnp

class BiLSTM_CRF(nn.Cell):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_tags, padding_idx=0):
        """
        初始化BiLSTM_CRF模型。
        
        参数:
        - vocab_size: 词汇表的大小
        - embedding_dim: 嵌入层的维度
        - hidden_dim: LSTM层的隐藏维度
        - num_tags: 标签的数量
        - padding_idx: 填充索引
        """
        super().__init__()
        # 初始化嵌入层
        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=padding_idx)
        # 初始化双向LSTM层
        self.lstm = nn.LSTM(embedding_dim, hidden_dim // 2, bidirectional=True, batch_first=True)
        # 初始化从LSTM输出到标签空间的全连接层
        self.hidden2tag = nn.Dense(hidden_dim, num_tags, 'he_uniform')
        # 初始化CRF层
        self.crf = CRF(num_tags, batch_first=True)

    def construct(self, inputs, seq_length, tags=None):
        """
        模型的前向传播函数。
        
        参数:
        - inputs: 输入序列的索引
        - seq_length: 序列的实际长度
        - tags: 真实标签序列（可选）
        
        返回:
        - crf_outs: CRF层的输出，可以是损失值或解码结果
        """
        # 将输入序列的索引通过嵌入层转换为嵌入向量
        embeds = self.embedding(inputs)
        # 通过LSTM层获取序列的特征表示
        outputs, _ = self.lstm(embeds, seq_length=seq_length)
        # 将LSTM的输出转换为标签空间的得分
        feats = self.hidden2tag(outputs)

        # 将特征和标签（如果提供）传递给CRF层
        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()
)]

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}

接下来实例化模型，选择优化器并将模型和优化器送入Wrapper。

由于CRF层已经进行了NLLLoss的计算，因此不需要再设置Loss。

import mindspore as ms
import mindspore.nn as nn

# 定义模型
model = BiLSTM_CRF(
    len(word_to_idx),  # 词汇表大小
    embedding_dim,     # 嵌入层维度
    hidden_dim,        # LSTM层的隐藏维度
    len(tag_to_idx)    # 标签数量
)

# 定义优化器
optimizer = nn.SGD(
    model.trainable_params(),  # 模型的可训练参数
    learning_rate=0.01,        # 学习率
    weight_decay=1e-4          # 权重衰减
)

# 使用MindSpore的value_and_grad函数获取梯度
grad_fn = ms.value_and_grad(model, None, optimizer.parameters())

def train_step(data, seq_length, label):
    """
    单步训练函数。
    
    参数:
    - data: 输入数据
    - seq_length: 序列的实际长度
    - label: 真实标签序列
    
    返回:
    - loss: 训练损失
    """
    # 计算损失和梯度
    loss, grads = grad_fn(data, seq_length, label)
    # 应用梯度
    optimizer(grads)
    return loss

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

import mindspore as ms

def prepare_sequence(seqs, word_to_idx, tag_to_idx):
    """
    准备序列标注任务的数据。
    
    参数:
    - seqs: 输入序列和标签的列表，每个元素是一个元组 (序列, 标签)
    - word_to_idx: 单词到索引的映射字典
    - tag_to_idx: 标签到索引的映射字典
    
    返回:
    - seq_tensor: 序列的索引张量
    - label_tensor: 标签的索引张量
    - seq_length_tensor: 序列长度的张量
    """
    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>']] * (max_len - len(seq)))
        labels.extend([tag_to_idx['O']] * (max_len - len(seq)))

        seq_outputs.append(idxs)  # 将索引列表添加到输出
        label_outputs.append(labels)  # 将标签索引列表添加到输出

    # 将列表转换为MindSpore Tensor
    return (
        ms.Tensor(seq_outputs, ms.int64),  # 序列索引张量
        ms.Tensor(label_outputs, ms.int64),  # 标签索引张量
        ms.Tensor(seq_length, ms.int64)  # 序列长度张量
    )

import mindspore as ms
import mindspore.numpy as mnp
from tqdm import tqdm

# 准备数据
data, label, seq_length = prepare_sequence(training_data, word_to_idx, tag_to_idx)

# 定义训练步骤数
steps = 500

# 使用tqdm库显示训练进度
with tqdm(total=steps) as t:
    for i in range(steps):
        # 执行单步训练，并获取损失
        loss = train_step(data, seq_length, label)
        # 更新tqdm的后缀，显示当前损失
        t.set_postfix(loss=loss)
        # 更新tqdm进度条
        t.update(1)

# 定义标签索引到标签的映射
idx_to_tag = {idx: tag for tag, idx in tag_to_idx.items()}

def sequence_to_tag(sequences, idx_to_tag):
    """
    将标签索引序列转换为标签序列。
    
    参数:
    - sequences: 标签索引序列的列表
    - idx_to_tag: 标签索引到标签的映射字典
    
    返回:
    - outputs: 标签序列的列表
    """
    outputs = []
    for seq in sequences:
        outputs.append([idx_to_tag[i] for i in seq])
    return outputs

学习心得:

序列标注是自然语言处理中的一项基础技术，广泛应用于命名实体识别、词性标注等任务。通过学习，我更加理解了它在信息提取中的关键作用。
通过学习，我了解到LSTM（长短期记忆网络）在处理序列数据时的优势，特别是其捕捉长期依赖关系的能力，这对于序列标注任务至关重要。
学习了CRF层在序列标注中的作用，理解了它如何通过考虑标签之间的转移概率来优化标注结果，提高模型的准确性。
学习了如何将LSTM与CRF结合起来构建一个完整的序列标注模型。这种结构利用了LSTM的序列特征提取能力和CRF的标签依赖建模能力。
在实现模型的过程中，我掌握了如何使用深度学习框架（如MindSpore）来构建和训练模型，包括数据预处理、模型定义、训练循环和结果评估。
学习了选择合适的损失函数和优化器对于模型训练的重要性。特别是在序列标注任务中，负对数似然损失和SGD优化器是常见的选择。

加油！！！

且ゞ行

关注

16
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
昇思25天学习打卡营第24天 | LSTM+CRF序列标注

本文介绍了如何使用长短期记忆网络（LSTM）和条件随机场（CRF）进行序列标注任务。通过结合LSTM的序列特征提取和CRF的标签依赖建模，构建了一个完整的命名实体识别模型。教程详细解释了模型架构、数据准备、训练过程，并提供了完整的代码实现和结果评估方法。
复制链接

扫一扫