概述
序列标注指给定输入序列,给序列中每个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)
设
x
=
{
x
0
,
.
.
.
,
x
n
}
x=\{x_0, ..., x_n\}
x={x0,...,xn}为输入序列,
y
=
{
y
0
,
.
.
.
,
y
n
}
,
y
∈
Y
y=\{y_0, ..., y_n\},y \in Y
y={y0,...,yn},y∈Y为输出的标注序列,其中
n
n
n为序列的最大长度,
Y
Y
Y表示
x
x
x对应的所有可能的输出序列集合。则输出序列
y
y
y的概率为:
P
(
y
∣
x
)
=
exp
(
Score
(
x
,
y
)
)
∑
y
′
∈
Y
exp
(
Score
(
x
,
y
′
)
)
(
1
)
\begin{align}P(y|x) = \frac{\exp{(\text{Score}(x, y)})}{\sum_{y' \in Y} \exp{(\text{Score}(x, y')})} \qquad (1)\end{align}
P(y∣x)=∑y′∈Yexp(Score(x,y′))exp(Score(x,y))(1)
设
x
i
x_i
xi,
y
i
y_i
yi为序列的第
i
i
i个Token和对应的标签,则
Score
\text{Score}
Score需要能够在计算
x
i
x_i
xi和
y
i
y_i
yi的映射的同时,捕获相邻标签
y
i
−
1
y_{i-1}
yi−1和
y
i
y_{i}
yi之间的关系,因此我们定义两个概率函数:
- 发射概率函数 ψ EMIT \psi_\text{EMIT} ψEMIT:表示 x i → y i x_i \rightarrow y_i xi→yi的概率。
- 转移概率函数
ψ
TRANS
\psi_\text{TRANS}
ψTRANS:表示
y
i
−
1
→
y
i
y_{i-1} \rightarrow y_i
yi−1→yi的概率。
则可以得到 Score \text{Score} Score的计算公式:
Score ( x , y ) = ∑ i log ψ EMIT ( x i → y i ) + log ψ TRANS ( y i − 1 → y i ) ( 2 ) \begin{align}\text{Score}(x,y) = \sum_i \log \psi_\text{EMIT}(x_i \rightarrow y_i) + \log \psi_\text{TRANS}(y_{i-1} \rightarrow y_i) \qquad (2)\end{align} Score(x,y)=i∑logψEMIT(xi→yi)+logψTRANS(yi−1→yi)(2)
设标签集合为
T
T
T,构造大小为
∣
T
∣
x
∣
T
∣
|T|x|T|
∣T∣x∣T∣的矩阵
P
\textbf{P}
P,用于存储标签间的转移概率;由编码层(可以为Dense、LSTM等)输出的隐状态
h
h
h可以直接视作发射概率,此时
Score
\text{Score}
Score的计算公式可以转化为:
Score
(
x
,
y
)
=
∑
i
h
i
[
y
i
]
+
P
y
i
−
1
,
y
i
(
3
)
\begin{align}\text{Score}(x,y) = \sum_i h_i[y_i] + \textbf{P}_{y_{i-1}, y_{i}} \qquad (3)\end{align}
Score(x,y)=i∑hi[yi]+Pyi−1,yi(3)
完整的CRF完整推导可参考Log-Linear Models, MEMMs, and CRFs
接下来我们根据上述公式,使用MindSpore来实现CRF的参数化形式。首先实现CRF层的前向训练部分,将CRF和损失函数做合并,选择分类问题常用的负对数似然函数(Negative Log Likelihood, NLL),则有:
Loss = − l o g ( P ( y ∣ x ) ) ( 4 ) \begin{align}\text{Loss} = -log(P(y|x)) \qquad (4)\end{align} Loss=−log(P(y∣x))(4)
由公式 ( 1 ) (1) (1)可得,
Loss = − l o g ( exp ( Score ( x , y ) ) ∑ y ′ ∈ Y exp ( Score ( x , y ′ ) ) ) ( 5 ) \begin{align}\text{Loss} = -log(\frac{\exp{(\text{Score}(x, y)})}{\sum_{y' \in Y} \exp{(\text{Score}(x, y')})}) \qquad (5)\end{align} Loss=−log(∑y′∈Yexp(Score(x,y′))exp(Score(x,y)))(5)
= l o g ( ∑ y ′ ∈ Y exp ( Score ( x , y ′ ) ) − Score ( x , y ) \begin{align}= log(\sum_{y' \in Y} \exp{(\text{Score}(x, y')}) - \text{Score}(x, y) \end{align} =log(y′∈Y∑exp(Score(x,y′))−Score(x,y)
根据公式 ( 5 ) (5) (5),我们称被减数为Normalizer,减数为Score,分别实现后相减得到最终Loss。
Score计算
首先根据公式 ( 3 ) (3) (3)计算正确标签序列所对应的得分,这里需要注意,除了转移概率矩阵 P \textbf{P} P外,还需要维护两个大小为 ∣ T ∣ |T| ∣T∣的向量,分别作为序列开始和结束时的转移概率。同时我们引入了一个掩码矩阵 m a s k mask mask,将多个序列打包为一个Batch时填充的值忽略,使得 Score \text{Score} Score计算仅包含有效的Token。
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)
# mask: (seq_length, batch_size)
seq_length, batch_size = tags.shape
mask = mask.astype(emissions.dtype)
# 将score设置为初始转移概率
# shape: (batch_size,)
score = start_trans[tags[0]]
# score += 第一次发射概率
# shape: (batch_size,)
score += emissions[0, mnp.arange(batch_size), tags[0]]
for i in range(1, seq_length):
# 标签由i-1转移至i的转移概率(当mask == 1时有效)
# shape: (batch_size,)
score += trans[tags[i - 1], tags[i]] * mask[i]
# 预测tags[i]的发射概率(当mask == 1时有效)
# shape: (batch_size,)
score += emissions[i, mnp.arange(batch_size), tags[i]] * mask[i]
# 结束转移
# shape: (batch_size,)
last_tags = tags[seq_ends, mnp.arange(batch_size)]
# score += 结束转移概率
# shape: (batch_size,)
score += end_trans[last_tags]
return score
Normalizer计算
根据公式
(
5
)
(5)
(5),Normalizer是
x
x
x对应的所有可能的输出序列的Score的对数指数和(Log-Sum-Exp)。此时如果按穷举法进行计算,则需要将每个可能的输出序列Score都计算一遍,共有
∣
T
∣
n
|T|^{n}
∣T∣n个结果。这里我们采用动态规划算法,通过复用计算结果来提高效率。
假设需要计算从第
0
0
0至第
i
i
i个Token所有可能的输出序列得分
Score
i
\text{Score}_{i}
Scorei,则可以先计算出从第
0
0
0至第
i
−
1
i-1
i−1个Token所有可能的输出序列得分
Score
i
−
1
\text{Score}_{i-1}
Scorei−1。因此,Normalizer可以改写为以下形式:
l
o
g
(
∑
y
0
,
i
′
∈
Y
exp
(
Score
i
)
)
=
l
o
g
(
∑
y
0
,
i
−
1
′
∈
Y
exp
(
Score
i
−
1
+
h
i
+
P
)
)
(
6
)
log(\sum_{y'_{0,i} \in Y} \exp{(\text{Score}_i})) = log(\sum_{y'_{0,i-1} \in Y} \exp{(\text{Score}_{i-1} + h_{i} + \textbf{P}})) \qquad (6)
log(y0,i′∈Y∑exp(Scorei))=log(y0,i−1′∈Y∑exp(Scorei−1+hi+P))(6)
其中
h
i
h_i
hi为第
i
i
i个Token的发射概率,
P
\textbf{P}
P是转移矩阵。由于发射概率矩阵
h
h
h和转移概率矩阵
P
\textbf{P}
P独立于
y
y
y的序列路径计算,可以将其提出,可得:
l
o
g
(
∑
y
0
,
i
′
∈
Y
exp
(
Score
i
)
)
=
l
o
g
(
∑
y
0
,
i
−
1
′
∈
Y
exp
(
Score
i
−
1
)
)
+
h
i
+
P
(
7
)
log(\sum_{y'_{0,i} \in Y} \exp{(\text{Score}_i})) = log(\sum_{y'_{0,i-1} \in Y} \exp{(\text{Score}_{i-1}})) + h_{i} + \textbf{P} \qquad (7)
log(y0,i′∈Y∑exp(Scorei))=log(y0,i−1′∈Y∑exp(Scorei−1))+hi+P(7)
根据公式(7),Normalizer的实现如下:
def compute_normalizer(emissions, mask, trans, start_trans, end_trans):
# emissions: (seq_length, batch_size, num_tags)
# mask: (seq_length, batch_size)
seq_length = emissions.shape[0]
# 将score设置为初始转移概率,并加上第一次发射概率
# shape: (batch_size, num_tags)
score = start_trans + emissions[0]
for i in range(1, seq_length):
# 扩展score的维度用于总score的计算
# shape: (batch_size, num_tags, 1)
broadcast_score = score.expand_dims(2)
# 扩展emission的维度用于总score的计算
# shape: (batch_size, 1, num_tags)
broadcast_emissions = emissions[i].expand_dims(1)
# 根据公式(7),计算score_i
# 此时broadcast_score是由第0个到当前Token所有可能路径
# 对应score的log_sum_exp
# shape: (batch_size, num_tags, num_tags)
next_score = broadcast_score + trans + broadcast_emissions
# 对score_i做log_sum_exp运算,用于下一个Token的score计算
# shape: (batch_size, num_tags)
next_score = ops.logsumexp(next_score, axis=1)
# 当mask == 1时,score才会变化
# shape: (batch_size, num_tags)
score = mnp.where(mask[i].expand_dims(1), next_score, score)
# 最后加结束转移概率
# shape: (batch_size, num_tags)
score += end_trans
# 对所有可能的路径得分求log_sum_exp
# shape: (batch_size,)
return ops.logsumexp(score, axis=1)
Viterbi算法
在完成前向训练部分后,需要实现解码部分。这里我们选择适合求解序列最优路径的Viterbi算法。与计算Normalizer类似,使用动态规划求解所有可能的预测序列得分。不同的是在解码时同时需要将第
i
i
i个Token对应的score取值最大的标签保存,供后续使用Viterbi算法求解最优预测序列使用。
取得最大概率得分
Score
\text{Score}
Score,以及每个Token对应的标签历史
History
\text{History}
History后,根据Viterbi算法可以得到公式:
P
0
,
i
=
m
a
x
(
P
0
,
i
−
1
)
+
P
i
−
1
,
i
P_{0,i} = max(P_{0, i-1}) + P_{i-1, i}
P0,i=max(P0,i−1)+Pi−1,i
从第0个至第
i
i
i个Token对应概率最大的序列,只需要考虑从第0个至第
i
−
1
i-1
i−1个Token对应概率最大的序列,以及从第
i
i
i个至第
i
−
1
i-1
i−1个概率最大的标签即可。因此我们逆序求解每一个概率最大的标签,构成最佳的预测序列。
由于静态图语法限制,我们将Viterbi算法求解最佳预测序列的部分作为后处理函数,不纳入后续CRF层的实现。
def viterbi_decode(emissions, mask, trans, start_trans, end_trans):
# emissions: (seq_length, batch_size, num_tags)
# mask: (seq_length, batch_size)
seq_length = mask.shape[0]
score = start_trans + emissions[0]
history = ()
for i in range(1, seq_length):
broadcast_score = score.expand_dims(2)
broadcast_emission = emissions[i].expand_dims(1)
next_score = broadcast_score + trans + broadcast_emission
# 求当前Token对应score取值最大的标签,并保存
indices = next_score.argmax(axis=1)
history += (indices,)
next_score = next_score.max(axis=1)
score = mnp.where(mask[i].expand_dims(1), next_score, score)
score += end_trans
return score, history
def post_decode(score, history, seq_length):
# 使用Score和History计算最佳预测序列
batch_size = seq_length.shape[0]
seq_ends = seq_length - 1
# shape: (batch_size,)
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
方法。
BiLSTM+CRF模型
在实现CRF后,我们设计一个双向LSTM+CRF的模型来进行命名实体识别任务的训练。模型结构如下:
nn.Embedding -> nn.LSTM -> nn.Dense -> CRF
其中LSTM提取序列特征,经过Dense层变换获得发射概率矩阵,最后送入CRF层。