BiLSTM+CRF及pytorch实现

目录

• 前言
• BiLSTM+CRF模型
  • 概述
  • 为什么需要添加CRF层？
  • CRF层
    • Emission score
    • Transition score
  • CRF损失函数
    • 实际路径得分
    • 所有可能的路径的总得分
  • 为新的句子推断标签(维特比解码)
• pytorch实现
• 参考

前言

对于命名实体识别任务，基于神经网络的方法非常普遍。例如，Neural Architectures for Named Entity Recognition提出了一个使用word and character embeddings的BiLSTM-CRF命名实体识别模型。我将以本文中的模型为例来解释CRF层是如何工作的。如果你不知道BiLSTM和CRF的细节，请记住它们是命名实体识别模型中的两个不同的层。

在开始我们下面将进行的讨论之前，我们先假设，我们有一个数据集，其中有两个实体类型：Person和Organization。但是，事实上，在我们的数据集中，我们有5个实体标签：

• B-Person
• I- Person
• B-Organization
• I-Organization
• O

此外，x是一个包含5个单词的句子，w0，w1，w2，w3，w4。更重要的是，在句子x中，[w0，w1]是一个Person实体，[w3]是一个Organization实体，其他都是“O”。

BiLSTM+CRF模型

概述

我将对这个模型做一个简单的介绍。
如下图所示：

• 首先，将句子x中的每个单词表示为一个向量，其中包括单词的嵌入和字符的嵌入。字符嵌入是随机初始化的。词嵌入通常是从一个预先训练的词嵌入文件导入的。所有的嵌入将在训练过程中进行微调。
• 第二，BiLSTM-CRF模型的输入是这些嵌入，输出是句子x中的单词的预测标签。
  

虽然不需要知道BiLSTM层的细节，但是为了更容易的理解CRF层，我们需要知道BiLSTM层输出的意义是什么。

上图说明BiLSTM层的输出是每个标签的分数。例如，对于w0, BiLSTM节点的输出为1.5 (B-Person)、0.9 (I-Person)、0.1 (B-Organization)、0.08 (I-Organization)和0.05 (O)，这些分数将作为CRF层的输入。
然后，将BiLSTM层预测的所有分数输入CRF层。在CRF层中，选择预测得分最高的标签序列作为最佳答案。

为什么需要添加CRF层？

你可能已经发现，即使没有CRF层，也就是说，我们可以训练一个BiLSTM命名实体识别模型，如下图所示。

因为每个单词的BiLSTM的输出是标签分数。我们可以选择每个单词得分最高的标签。例如，对于w0，“B-Person”得分最高(1.5)，因此我们可以选择“B-Person”作为其最佳预测标签。同样，我们可以为w1选择“I-Person”，为w2选择“O”，为w3选择“B-Organization”，为w4选择“O”。
虽然在这个例子中我们可以得到正确的句子x的标签，但是并不总是这样。再试一下下面图片中的例子。

显然，这次的输出是无效的，“I-Organization I-Person”和“B-Organization I-Person”。

CRF层可以向最终的预测标签添加一些约束，以确保它们是有效的。这些约束可以由CRF层在训练过程中从训练数据集自动学习。
约束条件可以是：

• 句子中第一个单词的标签应该以“B-”或“O”开头，而不是“I-”
• “B-label1 I-label2 I-label3 I-…”，在这个模式中，label1、label2、label3…应该是相同的命名实体标签。例如，“B-Person I-Person”是有效的，但是“B-Person I-Organization”是无效的。
• “O I-label”无效。一个命名实体的第一个标签应该以“B-”而不是“I-”开头，换句话说，有效的模式应该是“O B-label”
• …

有了这些有用的约束，无效预测标签序列的数量将显著减少。

CRF层

在这一节中，我将分析CRF损失函数，来解释CRF层如何或为什么能够从训练数据集中学习上述约束。
在CRF层的损失函数中，我们有两种类型的分数。这两个分数是CRF层的关键概念。

Emission score

第一个是emission分数。这些emission分数来自BiLSTM层。例如，如图2.1所示，标记为B-Person的w0的分数为1.5。

为了方便起见，我们将给每个标签一个索引号，如下表所示。

我们用\(x_{iy_j}\)来表示emission分数。\(i\)是word的索引，\(y_j\)是label的索引。如图2.1所示，\(x_{i=1,y_j=2} = x_{w_1,B-Organization} = 0.1\)，即 \(w_1\)作为B-Organization的得分为0.1。

Transition score

我们使用\(t_{y_iy_j}\)来表示transition分数。例如，\(t_{B-Person, I-Person} = 0.9\)表示标签的transition，\(B-Person \rightarrow I-Person\)得分为0.9。因此，我们有一个transition得分矩阵，它存储了所有标签之间的所有得分。
为了使transition评分矩阵更健壮，我们将添加另外两个标签，START和END。START是指一个句子的开头，而不是第一个单词。END表示句子的结尾。
下面是一个transition得分矩阵的例子，包括额外添加的START和END标签。

如上表所示，我们可以发现transition矩阵已经学习了一些有用的约束。

• 句子中第一个单词的标签应该以“B-”或“O”开头，而不是“I-”开头(从“START”到“I- person或I- organization”的transition分数非常低)
• “B-label1 I-label2 I-label3 I-…”，在这个模式中，label1、label2、label3…应该是相同的命名实体标签。例如，“B-Person I-Person”是有效的，但是“B-Person I-Organization”是无效的。(例如，从“B--- Organization”到“I-Person”的分数只有0.0003，比其他分数低很多)
• “O I-label”无效。一个被命名实体的第一个标签应该以“B-”而不是“I-”开头，换句话说，有效的模式应该是“O B-label”(同样，的分数非常小)
• …

你可能想问一个关于矩阵的问题。在哪里或如何得到transition矩阵？
实际上，该矩阵是BiLSTM-CRF模型的一个参数。在训练模型之前，可以随机初始化矩阵中的所有transition分数。所有的随机分数将在你的训练过程中自动更新。换句话说，CRF层可以自己学习这些约束。我们不需要手动构建矩阵。随着训练迭代次数的增加，分数会逐渐趋于合理。

CRF损失函数

CRF损失函数由真实路径得分和所有可能路径的总得分组成。在所有可能的路径中，真实路径的得分应该是最高的。
例如，如果我们的数据集中有如下表所示的这些标签：

我们还是有一个5个单词的句子。可能的路径是：

• 1. START B-Person B-Person B-Person B-Person B-Person END
• 2. START B-Person I-Person B-Person B-Person B-Person END
• …
• 10) START B-Person I-Person O B-Organization O END
• …
• N) O O O O O O O

假设每条可能的路径都有一个分数\(P_{i}\)，并且总共有\(N\)条可能的路径，所有路径的总分数是\(P_{total} = P_1 + P_2 + … + P_N = e^{S_1} + e^{S_2} + … + e^{S_N}\)。(在第2.4节中，我们将解释如何计算\(S_i\)，你也可以把它当作这条路径的分数。)
如果我们说第10条路径是真正的路径，换句话说，第10条路径是我们的训练数据集提供的黄金标准标签。在所有可能的路径中，得分\(P_{10}\)应该是百分比最大的。
在训练过程中，我们的BiLSTM-CRF模型的参数值将会一次又一次的更新，以保持增加真实路径的分数百分比。

\(Loss Function = \frac{P_{RealPath}}{P_1 + P_2 + … + P_N}\)

现在的问题是：

• 1)如何定义一个路径的分数？
• 2)如何计算所有可能路径的总分？
• 3)当我们计算总分时，我们需要列出所有可能的路径吗？(这个问题的答案是否定的.)

在下面的小节中，我们将看到如何解决这些问题。

实际路径得分

显然，在所有可能的路径中，一定有一条是真实路径。上节例子中句子的实际路径是“START B-Person I-Person O B-Organization O END”。其他的是不正确的，如“START B-Person B-Organization O I-Person I-Person B-Person”。\(e^{S_i}\)是第i条路径的得分。
在训练过程中，CRF损失函数只需要两个分数：真实路径的分数和所有可能路径的总分数。所有可能路径的分数中，真实路径分数所占的比例会逐渐增加。
计算实际路径分数\(e^{S_i}\)非常简单。这里我们主要关注的是\({S_i}\)的计算。
选取真实路径，“START B-Person I-Person O B-Organization O END”，我们以前用过，例如：

• 我们有一个5个单词的句子，w1,w2,w3,w4, w4,w5

• 我们增加了两个额外的单词来表示一个句子的开始和结束，w0,w6

• \({S_i}\)由两部分组成：\(S_i = EmissionScore + TransitionScore\)

Emission得分：
\(EmissionScore=x_{0,START}+x_{1,B-Person}+x_{2,I-Person}+x_{3,O}+x_{4,B-Organization}+x_{5,O}+x_{6,END}\)

• \(x_{index,label}\)是第index个单词被label标记的分数

• 这些得分$x_{1,B-Person} $ $ x_{2,I-Person} $ $ x_{3,O} $ $ x_{4,Organization} $ $ x_{5,O}$来自之前的BiLSTM输出。

• 对于\(x_{0,START}\)和\(x_{6,END}\)，我们可以把它们设为0。

Transition得分：

• \(t_{label1 \rightarrow label2}\)是从\(label1\)到\(label2\)的transition分数
• 这些分数来自CRF层。换句话说，这些transition分数实际上是CRF层的参数。

综上所述，现在我们可以计算出\(S_i\)以及路径得分\(e^{S_i}\)。

所有可能的路径的总得分

衡量总分最简单的方法是：列举所有可能的路径并将它们的分数相加。是的，你可以用这种方法计算总分。然而，这是非常低效的。训练的时间将是难以忍受的。下面我们将会通过一个toy例子，如何逐步计算一个句子的所有可能的路径的总分。下面我们开始在探索吧。

步骤1: 回想一下CRF损失函数
之前，我们将CRF损失函数定义为：

\(Loss Function = \frac{P_{RealPath}}{P_1 + P_2 + … + P_N}\)

现在我们把loss函数改变为对数loss函数：

\(LogLossFunction = \log \frac{P_{RealPath}}{P_1 + P_2 + … + P_N}\)

当我们训练一个模型时，通常我们的目标是最小化我们的损失函数，因此我们加上一个负号：

\(Log Loss Function = - \log \frac{P_{RealPath}}{P_1 + P_2 + … + P_N}\)

\(= - \log \frac{e^{S_{RealPath}}}{e^{S_1} + e^{S_2} + … + e^{S_N}}\)

\(= - (\log(e^{S_{RealPath}}) - \log(e^{S_1} + e^{S_2} + … + e^{S_N}))\)

\(= - (S_{RealPath} - \log(e^{S_1} + e^{S_2} + … + e^{S_N}))\)

\(= - ( \sum_{i=1}^{N} x_{iy_i} + \sum_{i=1}^{N-1} t_{y_iy_{i+1}} - \log(e^{S_1} + e^{S_2} + … + e^{S_N}))\)

在上一节中，我们已经知道如何计算实际路径得分，现在我们需要找到一个有效的解决方案来计算\(\log(e^{S_1} + e^{S_2} + … + e^{S_N})\)

步骤2: 回忆一下Emission和Transition得分
为了简化，我们假设我们从这个toy句子中训练我们的模型，它的长度只有3：
\(\mathbf{x} = [w_0, w_1, w_2]\)
此外，在我们的数据集中，我们有两个标签：
\(LabelSet = \{l_1,l_2\}\)
我们还有Bi-LSTM层输出的Emission分数：

\(x_{ij}\)表示\(w_i\)被标记为\(l_j\)的得分。
此外，还有来自CRF层的Transition分数：

\(t_{ij}\)是从标签i到标签j的transition得分。

步骤3: 开始战斗（准备好纸笔）:
Remeber: Our goal is: \(log(e^{S1}+e^{S2}+…+e^{SN})\)

---

这个过程就是分数的累加。其思想与动态规划相似。简而言之，计算w0的所有可能路径的总分。然后，我们用总分来计算w0→w1。最后，我们使用最新的总分来计算w0→w1→w2。我们需要的是最后的总分。 在接下来的步骤中，你将看到两个变量：obs和previous。previous存储前面步骤的最终结果。obs表示当前单词的信息。

• previous：是一个向量，维数为标签tag的个数，每一维存储的是上一个位置所有的以某个tag为结尾的路径总分数的log之后的值
• obs：是一个向量，维数为标签tag的个数，每一维存储的是当前位置所对应的为某个tag的emission score。

---

w0:

\(obs = [x_{01}, x_{02}]\)
\(previous = None\)

如果我们的句子只有一个单词\(w_0\)，我们就没有前面步骤的结果，因此\(previous\)是\(None\)。另外，我们只能观察到第一个词\(obs = [x_{01}, x_{02}]\)。\(x_{01}\)和\(x_{02}\)是上述的Emission分数。
你可能会想，\(w_0\)的所有可能路径的总分是多少？答案很简单：

\(TotalScore(w_0)=\log (e^{x_{01}} + e^{x_{02}})\)

---

w0 \(\rightarrow\) w1:

\(obs = [x_{11}, x_{12}]\)
\(previous = [x_{01}, x_{02}]\)

1)把previous展开成：

\(previous =\left( \begin{matrix} x_{01}&x_{01}\\x_{02}&x_{02} \end{matrix} \right)\)

2)把obs展开成：
\(obs =\left( \begin{matrix} x_{11}&x_{12}\\ x_{11}&x_{12} \end{matrix} \right)\)

你可能想知道，为什么我们需要把previous和obs扩展成矩阵。因为矩阵可以提高计算的效率。在下面的过程中，你将很快看到这一点。
3)对 previous, obs以及transition得分求和：
\(scores =\left( \begin{matrix} x_{01}&x_{01}\\x_{02}&x_{02} \end{matrix} \right) + \left( \begin{matrix} x_{11}&x_{12}\\x_{11}&x_{12} \end{matrix} \right) + \left( \begin{matrix} t_{11}&t_{12}\\t_{21}&t_{22} \end{matrix} \right)\)

然后：
\(scores =\left( \begin{matrix} x_{01}+x_{11}+t_{11}&x_{01}+x_{12}+t_{12}\\ x_{02}+x_{11}+t_{21}&x_{02}+x_{12}+t_{22} \end{matrix} \right)\)

为下一个迭代修改previous的值：
\(previous=[\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}}), \log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})]\)

实际上，第二次迭代已经完成。如果有人想知道如何计算所有可能路径的总分(\(label_1\) \(\rightarrow\) \(label_1\), \(label_1\) \(\rightarrow\) \(label_2\), \(label_2\) \(\rightarrow\) \(label_1\), \(label_2\) \(\rightarrow\) \(label_2\))，从\(w_0\)到\(w_1\)，可以做如下计算。

我们使用新的previous中的元素：

\(TotalScore(w_0 \rightarrow w_1)\)
\( =\log (e^{previous[0]} + e^{previous[1]})\)
\( =\log (e^{\log(e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})}+e^{\log(e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})})\)
\( =\log(e^{x_{01}+x_{11}+t_{11}}+e^{x_{02}+x_{11}+t_{21}}+e^{x_{01}+x_{12}+t_{12}}+e^{x_{02}+x_{12}+t_{22}})\)

你发现了吗？这正是我们的目标：\(\log(e^{S_1} + e^{S_2} + … + e^{S_N})\)
在这个等式中，我们可以看到：

• \(S_1 = x_{01}+x_{11}+t_{11}\) (\(label_1\) → \(label_1\))
• \(S_2 = x_{02}+x_{11}+t_{21}\) (\(label_2\) → \(label_1\))
• \(S_3 = x_{01}+x_{12}+t_{12}\) (\(label_1\) → \(label_2\))
• \(S_4 = x_{02}+x_{12}+t_{22}\) (\(label_2\) → \(label_2\))

---

w0 → w1 → w2:

如果你读到这里了，你已经快要读完了，实际上，在这个迭代里，我们做的事情是和上个迭代一样的。
\(obs = [x_{21}, x_{22}]\)
\(previous=[\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}}), \log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})]\)

1)把previous扩展成：
\(previous =\left( \begin{matrix} \log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})&\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})\\ \log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})&\log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}}) \end{matrix} \right)\)

2)把obs扩展成：
\(obs =\left( \begin{matrix} x_{21}&x_{22}\\ x_{21}&x_{22} \end{matrix} \right)\)

3)把previous, obs和transition分数加起来:
\(scores = \left( \begin{matrix} \log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})&\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})\\ \log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})&\log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}}) \end{matrix} \right) + \left( \begin{matrix} x_{21}&x_{22}\\ x_{21}&x_{22} \end{matrix} \right) + \left( \begin{matrix} t_{11}&t_{12}\\ t_{21}&t_{22} \end{matrix} \right)\)

然后：
\(scores = \left( \begin{matrix} \log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}}) + x_{21} + t_{11} &\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}}) + x_{22} + t_{12}\\ \log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}}) + x_{21} + t_{21} &\log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}}) + x_{22} + t_{22} \end{matrix} \right)\)

为下一轮迭代改变previous的值：
\(previous=[\) \(\log( e^{\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}}) + x_{21} + t_{11}} + e^{\log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}}) + x_{21} + t_{21}} )\),\(\log( e^{\log (e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}}) + x_{22} + t_{12}} + e^{\log (e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}}) + x_{22} + t_{22}})\)]

\(=[\log((e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})e^{x_{21} + t_{11}}+(e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})e^{x_{21} + t_{21}}),\log((e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})e^{x_{22} + t_{12}}+(e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})e^{x_{22} + t_{22}})]\)

就像上一个迭代描述的一样，我们使用新的previous中的元素来计算总分数：
\(TotalScore(w_0 \rightarrow w_1 \rightarrow w_2)\)
\(=\log (e^{previous[0]} + e^{previous[1]})\)
\(=\log (e^{\log((e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})e^{x_{21} + t_{11}}+(e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})e^{x_{21} + t_{21}})}+e^{\log((e^{x_{01}+x_{11}+t_{11}} + e^{x_{02}+x_{11}+t_{21}})e^{x_{22} + t_{12}}+(e^{x_{01}+x_{12}+t_{12}} + e^{x_{02}+x_{12}+t_{22}})e^{x_{22} + t_{22}})})\)
\(=\log (e^{x_{01}+x_{11}+t_{11}+x_{21}+t_{11}}+e^{x_{02}+x_{11}+t_{21}+x_{21}+t_{11}}+e^{x_{01}+x_{12}+t_{12}+x_{21}+t_{21}}+e^{x_{02}+x_{12}+t_{22}+x_{21}+t_{21}}+e^{x_{01}+x_{11}+t_{11}+x_{22}+t_{12}}+e^{x_{02}+x_{11}+t_{21}+x_{22}+t_{12}}+e^{x_{01}+x_{12}+t_{12}+x_{22}+t_{22}}+e^{x_{02}+x_{12}+t_{22}+x_{22}+t_{22}})\)

我们达到了目标，\(\log(e^{S_1} + e^{S_2} + … + e^{S_N})\).我们的toy句子有三个单词，label set有两个label，所以一共应该有8种可能的label path。

---

虽然这个过程相当复杂，但是实现这个算法要容易得多。使用计算机的优点之一是可以完成一些重复性的工作。

为新的句子推断标签(维特比解码)

在前面的章节中，我们学习了BiLSTM-CRF模型的结构和CRF损失函数的细节。你可以通过各种开源框架(Keras、TensorFlow、pytorch等)实现自己的BiLSTM-CRF模型。最重要的事情之一是模型的反向传播是在这些框架上自动计算的，因此你不需要自己实现反向传播来训练你的模型(即计算梯度和更新参数)。此外，一些框架已经实现了CRF层，因此将CRF层与你自己的模型结合起来非常容易，只需添加一行代码即可。

在本节中，我们将探索如何在模型准备好时在测试期间推断句子的标签。

步骤1：BiLSTM-CRF模型的Emission和transition得分
假设，我们有一个包含三个单词的句子：\(\mathbf{x} = [w_0, w_1, w_2]\)
此外，我们已经从BiLSTM模型得到了Emission分数，从下面的CRF层得到了transition分数：

	l1	l2
w0	x01	x02
w1	x11	x12
w2	x21	x22

\(x_{ij}\)表示\(w_i\)被标记为\(l_j\)的得分。

	l1	l2
l1	t11	t12
l2	t21	t22

\(t_{ij}\)是从标签i转换成标签j的得分。

步骤2：开始推断

---

如果你熟悉Viterbi算法，那么这一部分对你来说很容易。但如果你不熟悉，请不要担心。与前一节类似，我将逐步解释该算法(先进行一个从左到右的前向过程，再从右到左进行回溯)。我们将从句子的左到右进行推断算法，如下所示：

• w0
• w0 → w1
• w0 → w1 → w2

你会看到两个变量：obs和previous。previous存储前面步骤的最终结果。obs表示当前单词的信息。
\(\mathbf{alpha_0}\)是历史最好得分，\(\mathbf{alpha_1}\)是历史对应的索引。这两个变量的细节将在它们出现时进行解释(方便我们进行回溯)。

---

w0:

\(obs = [x_{01}, x_{02}]\)
\(previous = None\)

现在，我们观察第一个单词\(w_{0}\)，目前为止，\(w_{0}\)最好的标签是很明显的。
比如，如果\(obs = [x_{01}=0.2, x_{02}=0.8]\)，很显然，\(w_{0}\)的最佳的标签是\(l_2\)。
因为只有一个单词，而且没有标签直接的转换，transition的得分没有用到。

---

w0 → w1:
\(obs = [x_{11}, x_{12}]\)
\(previous = [x_{01}, x_{02}]\)

1)把previous扩展成：
\(previous = \left( \begin{matrix} previous[0]&previous[0]\\ previous[1]&previous[1] \end{matrix} \right)= \left( \begin{matrix} x_{01}&x_{01}\\ x_{02}&x_{02} \end{matrix} \right)\)

2)把obs扩展成：
\(obs = \left( \begin{matrix} obs[0]&obs[1]\\ obs[0]&obs[1] \end{matrix} \right)= \left( \begin{matrix} x_{11}&x_{12}\\ x_{11}&x_{12} \end{matrix} \right)\)

3)把previous, obs和transition 分数都加起来：
\(scores = \left( \begin{matrix} x_{01}&x_{01}\\ x_{02}&x_{02} \end{matrix} \right) + \left( \begin{matrix} x_{11}&x_{12}\\ x_{11}&x_{12} \end{matrix} \right) + \left( \begin{matrix} t_{11}&t_{12}\\ t_{21}&t_{22} \end{matrix} \right)\)

然后：
\(scores = \left( \begin{matrix} x_{01}+x_{11}+t_{11}&x_{01}+x_{12}+t_{12}\\ x_{02}+x_{11}+t_{21}&x_{02}+x_{12}+t_{22} \end{matrix} \right)\)

你可能好奇，当我们计算所有路径的总分时，与上一节没有什么不同。请耐心和细心，你很快就会看到区别。
为下一次迭代更改previous的值：

\(previous=[\max (scores[00], scores[10]),\max (scores[01],scores[11])]\)

比如，如果我们的得分是：
\(scores = \left( \begin{matrix} x_{01}+x_{11}+t_{11}&x_{01}+x_{12}+t_{12}\\ x_{02}+x_{11}+t_{21}&x_{02}+x_{12}+t_{22} \end{matrix} \right)\) \(= \left( \begin{matrix} 0.2&0.3\\ 0.5&0.4 \end{matrix} \right)\)

我们的下个迭代的previous是：
\(previous=[\max (scores[00], scores[10]),\max (scores[01],scores[11])] = [0.5, 0.4]\)

previous列表存储了当前单词的每个标签的最大得分。

[Example Start]

举个例子：
我们知道在我们的语料中，我们总共只有2个标签，\(label1(l_1)\)和\(label2(l_2)\)。这两个标签的索引分别是0和1(因为在程序中index从0开始而不是1)。
\(previous[0]\)是以第0个标签\(l_1\)为结尾的路径的最大得分，类似的previous[1]是以第1个标签\(l_2\)为结尾的路径的最大得分。在每个迭代中，变量previous存储了以每个标签为结尾的路径的最大得分。换句话说，在每个迭代中，我们只保留了每个标签的最佳路径的信息 \((previous=[max(scores[00],scores[10]),max(scores[01],scores[11])])\)
具有小得分的路径信息会被丢掉。

[Example End]

回到我们的主任务：
同时，我们还有两个变量用来存储历史信息（得分和索引），\(alpha_0\)和\(alpha_1\)。
在这个迭代中，我们把最佳得分放入\(alpha_0\)，为了方便，每个标签的最大得分会加上下划线。

\(scores = \left( \begin{matrix} x_{01}+x_{11}+t_{11}&x_{01}+x_{12}+t_{12}\\ \underline{x_{02}+x_{11}+t_{21}}&\underline{x_{02}+x_{12}+t_{22}} \end{matrix} \right)= \left( \begin{matrix} 0.2&0.3\\ \underline{0.5}&\underline{0.4} \end{matrix} \right)\)

\(alpha_0=[(scores[10],scores[11])]=[(0.5,0.4)]\)

另外，对应的列的索引(当前词前一个词的状态的index)存在\(alpha_1\)里。

\(alpha_1=[(ColumnIndex(scores[10]),ColumnIndex(scores[11]))]=[(1,1)]\)

说明一下，\(l_1\)的索引是0，\(l_2\)的索引是1，所以\((1,1)=(l_2,l_2)\)表示,对于当前的单词\(w_i\)和标签\(l^{(i)}\):
当路径是\(\underline{l^{(i-1)}=l_2}\) → \(\underline{l^{(i)}=l_1}\)的时候，我们可以得到最大的得分是0.5，当路径是\(\underline{l^{(i-1)}=l_2}\) → \(\underline{l^{(i)}=l_2}\)的时候，我们可以得到最大的得分是0.4。\(l^{(i-1)}\)是前一个单词\(w_{i-1}\)的标签。

---

w0 → w1 → w2:

\(obs = [x_{21}, x_{22}]\)
\(previous = [0.5, 0.4]\)

1)把previous扩展成：
\(previous = \left( \begin{matrix} previous[0]&previous[0]\\ previous[1]&previous[1] \end{matrix} \right)= \left( \begin{matrix} 0.5&0.5\\ 0.4&0.4 \end{matrix} \right) \)

2)把obs扩展成：
\(obs = \left( \begin{matrix} obs[0]&obs[1]\\ obs[0]&obs[1] \end{matrix} \right)= \left( \begin{matrix} x_{21}&x_{22}\\ x_{21}&x_{22} \end{matrix} \right)\)

3)把previous, obs和transition 分数都加起来：
\(scores = \left( \begin{matrix} 0.5&0.5\\ 0.4&0.4 \end{matrix} \right) + \left( \begin{matrix} x_{21}&x_{22}\\ x_{21}&x_{22} \end{matrix} \right) + \left( \begin{matrix} t_{11}&t_{12}\\ t_{21}&t_{22} \end{matrix} \right)\)

然后：
\(scores = \left( \begin{matrix} 0.5+x_{11}+t_{11}&0.5+x_{12}+t_{12}\\ 0.4+x_{11}+t_{21}&0.4+x_{12}+t_{22} \end{matrix} \right)\)

为下一次迭代改变previous的值：

\(previous=[\max (scores[00], scores[10]),\max (scores[01],scores[11])]\)

Let’s say,这次迭代我们得到的分数是：

\(scores = \left( \begin{matrix} 0.6&\underline{0.9}\\ \underline{0.8}&0.7 \end{matrix} \right)\)

我们得到最新的previous：
\(previous=[0.8,0.9]\)
实际上，previous[0]和previous[1]中最大的那个就是预测的最佳路径。
同时，每个标签的最大分数和对应的索引会添加到\(alpha_0\)上和\(alpha_1\)上。

\(alpha_0=[(0.5,0.4),\underline{(scores[10],scores[01])}]\)
\(=[(0.5,0.4),\underline{(0.8,0.9)}]\)
\(alpha_1=[(1,1),\underline{(1,0)}]\)

步骤3：找到具有最高得分的最佳路径
这是最后一步,在此步骤中，将使用\(alpha_0\)和\(alpha_1\)来查找得分最高的路径。我们将从最后一个到第一个地去检查这两个列表中的元素。

---

\(w_1\) → \(w_2\):
首先，检查\(alpha_0\)和\(alpha_1\)的最后一个元素：\((0.8,0.9)\)和\((1,0)\)。0.9表示当label为\(l_2\)时，我们可以得到最高的路径分数0.9。我们还知道\(l_2\)的索引是1，因此检查\((1,0)[1]=0\)的值。索引“0”表示前一个标签为 \(l_1\)(\(l_1\)的索引为0)，因此我们可以得到 \(w_1\) → \(w_2\)的最佳路径：是\(l_1\) → \(l_2\)。

\(w_0\) → \(w_1\):

然后，我们继续向回移动并从\(alpha_1\)中得到元素：\((1,1)\)。从上一段我们知道\(w_1\)的label是\(l_1\)(index是0)，因此我们可以检查\((1,1)[0]=1\)。因此，我们可以得到这部分(\(w_0\) → \(w_1\))的最佳路径: \(l_2\) → \(l_1\)。

最后，我们这个例子中的最佳路径是\(l_2\) → \(l_1\) → \(l_2\)。

pytorch实现

上面已经把BiLSTM+CRF讲的清清楚楚了，光看理论还不够，我们要深入代码实战环节。

我们首先导入相应的包和定义一些后面要用到的辅助函数，如下，

import torch
import torch.nn as nn
import torch.optim as optim

torch.manual_seed(1)

# some helper functions
def argmax(vec):
    # return the argmax as a python int
    # 第1维度上最大值的下标
    # input: tensor([[2,3,4]])
    # output: 2
    _, idx = torch.max(vec,1)
    return idx.item()

def prepare_sequence(seq,to_ix):
    # 文本序列转化为index的序列形式
    idxs = [to_ix[w] for w in seq]
    return torch.tensor(idxs, dtype=torch.long)

# 这个函数的作用等价于torch.log(torch.sum(torch.exp(vec)))
def log_sum_exp(vec):
    #compute log sum exp in a numerically stable way for the forward algorithm
    # input: tensor([[2,3,4]])
    # max_score_broadcast: tensor([[4,4,4]])
    max_score = vec[0, argmax(vec)]
    max_score_broadcast = max_score.view(1,-1).expand(1,vec.size()[1])
    return max_score+torch.log(torch.sum(torch.exp(vec-max_score_broadcast)))

这里定义的几个辅助函数都比较直观，唯独log_sum_exp可能会对大家造成一点困扰，但其实这是一种考虑数值稳定性的求解办法，具体大家参考这篇博文即可。

我们接着看模型的定义，

# create model
class BiLSTM_CRF(nn.Module):
    def __init__(self,vocab_size, tag2ix, embedding_dim, hidden_dim):
        super(BiLSTM_CRF,self).__init__()
        self.embedding_dim = embedding_dim
        self.hidden_dim = hidden_dim
        self.tag2ix = tag2ix
        self.tagset_size = len(tag2ix)
        # 这里的单词嵌入矩阵是真实的单词嵌入矩阵，不包含在句子开始和结尾添加的人为的开始单词、结束单词
        self.word_embeds = nn.Embedding(vocab_size, embedding_dim)
        # LSTM默认数据格式batch_first = false
        self.lstm = nn.LSTM(embedding_dim, hidden_dim//2, num_layers=1, bidirectional=True)

        # maps output of lstm to tog space
        # 也即每个单词产生的Emission(发射) Score分布包含产生"<s>"和"<e>"的概率
        self.hidden2tag = nn.Linear(hidden_dim, self.tagset_size)

        # matrix of transition parameters
        # entry i, j is the score of transitioning to i from j
        # 所以，transition矩阵的每一列的元素之和为1
        # tag间的转移矩阵，是CRF层的参数
        # 这个transition矩阵包括"<s>" tag,"<e>" tag
        self.transitions = nn.Parameter(torch.randn(self.tagset_size, self.tagset_size))

        # these two statements enforce the constraint that we never transfer to the start tag
        # and we never transfer from the stop tag
        self.transitions.data[tag2ix[START_TAG], :] = -10000
        self.transitions.data[:, tag2ix[END_TAG]] = -10000
        
        self.hidden = self.init_hidden()
    # 作为lstm刚开始输入时的初值(h_0,c_0)，为一个元组
    # 初值的维数为num_layers * num_directions, batch, hidden_size
    # 说明一批中训练计算时用的是一样的h_0,c_0，不同批次使用的是不同的h_0,c_0
    def init_hidden(self):
        return (torch.randn(2, 1,self.hidden_dim//2),
                torch.randn(2, 1,self.hidden_dim//2))
    
    # 求log(e^s1 + e^s2 + e^s3 + ... + e^sN)的值，应用动态归化算法
    def _forward_alg(self, feats):
        # Do the forward algorithm to compute the partition(分治) function
        init_alphas = torch.full((1,self.tagset_size), -10000.)# tensor([[-10000.,-10000.,-10000.,-10000.,-10000.]])
        # START_TAG has all of the score
        init_alphas[0][self.tag2ix[START_TAG]] = 0#tensor([[-10000.,-10000.,-10000.,0,-10000.]])
        # Wrap in a variable so that we will get automatic backprop
        forward_var = init_alphas
        # Iterate through the sentence
        for feat in feats:
            #feat指Bi-LSTM模型每一步的输出，大小为tagset_size
            alphas_t = []# The forward tensors at this timestep
            for next_tag in range(self.tagset_size):
                # broadcast the emission score: it is the same regardless of(不管) the previous tag
                emit_score = feat[next_tag].view(1,-1).expand(1,self.tagset_size)
                # the ith entry of trans_score is the score of transitioning to next_tag from i
                trans_score = self.transitions[next_tag].view(1,-1)
                # The ith entry of next_tag_var is the value for the
                # edge (i -> next_tag) before we do log-sum-exp
                next_tag_var = forward_var + trans_score + emit_score
                # The forward variable for this tag is log-sum-exp of all the
                # scores.
                alphas_t.append(log_sum_exp(next_tag_var).view(1))
            forward_var = torch.cat(alphas_t).view(1,-1)
        terminal_var = forward_var+self.transitions[self.tag2ix[END_TAG]]
        alpha = log_sum_exp(terminal_var)
        return alpha

    def _get_lstm_features(self,sentence):
        self.hidden = self.init_hidden()
        embeds = self.word_embeds(sentence).view(len(sentence),1,-1)
        lstm_out, self.hidden = self.lstm(embeds, self.hidden)
        lstm_out = lstm_out.view(len(sentence), self.hidden_dim)
        lstm_feats = self.hidden2tag(lstm_out)
        return lstm_feats

    def _score_sentence(self,feats,tags):
        # gives the score of a provides tag sequence
        # 求某一路径的值
        score = torch.zeros(1)
        tags = torch.cat([torch.tensor([self.tag2ix[START_TAG]], dtype=torch.long), tags])
        # feats中的i位置对应tags中的i+1位置
        # 这里的实现版本的emisson score为句子所有的真实单词位置的，不包含人为添加的START_TAG位置和END_TAG位置
        # 而transition score则包含START_TAG位置 -> 句子的第一个真实单词之间的转换分数
        # 和句子的最后一个真实单词 -> END_TAG位置之间的转换分数 
        for i , feat in enumerate(feats):
            score = score + self.transitions[tags[i + 1], tags[i]] + feat[tags[i + 1]]
        score = score + self.transitions[self.tag2ix[END_TAG], tags[-1]]
        return score

    def _viterbi_decode(self, feats):
        backpointers = []
        # Initialize the viterbi variables in log space
        init_vars = torch.full((1,self.tagset_size),-10000.)# tensor([[-10000.,-10000.,-10000.,-10000.,-10000.]])
        init_vars[0][self.tag2ix[START_TAG]] = 0#tensor([[-10000.,-10000.,-10000.,0,-10000.]])
        # forward_var at step i holds the viterbi variables for step i-1
        forward_var = init_vars
        for feat in feats:
            bptrs_t = [] # holds the back pointers for this step
            viterbivars_t = [] # holds the viterbi variables for this step

            for next_tag in range(self.tagset_size):
                # next_tag_var[i] holds the viterbi variable for tag i at the
                # previous step, plus the score of transitioning
                # from tag i to next_tag.
                # We don't include the emission scores here because the max
                # does not depend on them (we add them in below)
                next_tag_var = forward_var + self.transitions[next_tag]
                best_tag_id = argmax(next_tag_var)
                bptrs_t.append(best_tag_id)
                viterbivars_t.append(next_tag_var[0][best_tag_id].view(1))
            # Now add in the emission scores, and assign forward_var to the set
            # of viterbi variables we just computed
            forward_var = (torch.cat(viterbivars_t) + feat).view(1, -1)
            backpointers.append(bptrs_t)

        # Transition to STOP_TAG
        terminal_var = forward_var + self.transitions[self.tag2ix[END_TAG]]
        best_tag_id = argmax(terminal_var)
        path_score = terminal_var[0][best_tag_id]

        # Follow the back pointers to decode the best path.
        best_path = [best_tag_id]
        for bptrs_t in reversed(backpointers):
            best_tag_id = bptrs_t[best_tag_id]
            best_path.append(best_tag_id)
        # Pop off the start tag (we dont want to return that to the caller)
        start = best_path.pop()
        assert start == self.tag2ix[START_TAG]  # Sanity check
        best_path.reverse()
        return path_score, best_path
    # 注意，这里的实现为单个句子版本，不是批版本
    def neg_log_likelihood(self, sentence, tags):
        # 由lstm层计算得的每一时刻属于某一tag的值
        feats = self._get_lstm_features(sentence)
        # log(e^s1 + e^s2 + e^s3 + ... + e^sN)
        forward_score = self._forward_alg(feats)
        # 正确路径的值，s_realpath
        gold_score = self._score_sentence(feats, tags)
        # -(s_realpath - log(e^s1 + e^s2 + e^s3 + ... + e^sN)）
        return forward_score - gold_score

    def forward(self, sentence):  # dont confuse this with _forward_alg above.
        # Get the emission scores from the BiLSTM
        lstm_feats = self._get_lstm_features(sentence)

        # Find the best path, given the features.
        score, tag_seq = self._viterbi_decode(lstm_feats)
        return score, tag_seq

上面的注释应该说很详细了，只有CRF层是需要自己手写出来的。所以，大家重点关注一下_forward_alg这个函数，就是我们上面讲的求解\(\log(e^{S_1} + e^{S_2} + … + e^{S_N})\)的函数，关于这个函数的计算原理，上面已经通过例子展示过了，为了更清晰一点，这里把用动态规划时的递推公式原理写出来，以利于理解。
对于一个序列，假设它有N个解码路径，我们要求的是\(\log(e^{S_1} + e^{S_2} + … + e^{S_N})\)，直接求一个一个地算，太麻烦，复杂度很好，所以我们使用了动态规划的思想，逐个时间步的计算，在每个时间步t，我们维护一个长度为tag_size的向量\(cur^t\)(这里只是为了论述的方便，没用代码了的变量)，
\(cur^t[j] = logsumexp(S^t_1,S^t_2,S^t_3,...,S^t_{N_j})\)，其中\(S^t_1,S^t_2,S^t_3,...,S^t_{N_j}\)为从序列开始到此时间步t的所有路径中时间步t标签为j的路径的各自得分。则：


而我们最终要求的结果\(\log(e^{S_1} + e^{S_2} + … + e^{S_N})\)显然等于：
\(logsumexp(cur^{terminal})\)
terminal为最终时间步。

最后，我们再来看一下主函数，

if __name__ == "__main__":
    START_TAG = "<s>"
    END_TAG = "<e>"
    EMBEDDING_DIM = 5
    HIDDEN_DIM = 4

    # Make up some training data
    # 注意：这里的两个样本的长度不一样长
    training_data = [(
        "the wall street journal reported today that apple corporation made money".split(),
        "B I I I O O O B I O O".split()
    ), (
        "georgia tech is a university in georgia".split(),
        "B I O O O O B".split()
    )]
    # 构造单词->单词序号的映射字典(这个字典中不包括人为的句子开始单词："<START>"，以及人为的句子结束单词："<STOP>")
    word2ix = {}
    for sentence, tags in training_data:
        for word in sentence:
            if word not in word2ix:
                word2ix[word] = len(word2ix)

    tag2ix = {"B": 0, "I": 1, "O": 2, START_TAG: 3, END_TAG: 4}

    model = BiLSTM_CRF(len(word2ix), tag2ix, EMBEDDING_DIM, HIDDEN_DIM)
    optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)

    # Check predictions before training
    # 输出训练前的预测序列
    with torch.no_grad():
        precheck_sent = prepare_sequence(training_data[0][0], word2ix)
        precheck_tags = torch.tensor([tag2ix[t] for t in training_data[0][1]], dtype=torch.long)
        print(model(precheck_sent))

    # Make sure prepare_sequence from earlier in the LSTM section is loaded
    for epoch in range(300):  # again, normally you would NOT do 300 epochs, it is toy data
        for sentence, tags in training_data:
            # Step 1. Remember that Pytorch accumulates gradients.
            # We need to clear them out before each instance
            model.zero_grad()

            # Step 2. Get our inputs ready for the network, that is,
            # turn them into Tensors of word indices.
            # 注意：这里的model的输入sentence_in：句子的单词index序列没有经过额外的处理(人为地增加句子开始、结束单词)
            sentence_in = prepare_sequence(sentence, word2ix)
            # 训练时，句子的tags序列也没有经过额外的处理(人为地增加句子开始、结束tag)
            targets = torch.tensor([tag2ix[t] for t in tags], dtype=torch.long)

            # Step 3. Run our forward pass.
            loss = model.neg_log_likelihood(sentence_in, targets)

            # Step 4. Compute the loss, gradients, and update the parameters by
            # calling optimizer.step()
            loss.backward()
            optimizer.step()

    # Check predictions after training
    with torch.no_grad():
        precheck_sent = prepare_sequence(training_data[0][0], word2ix)
        print(model(precheck_sent))

    # 输出结果
    # (tensor(-9996.9365), [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
    # (tensor(-9973.2725), [0, 1, 1, 1, 2, 2, 2, 0, 1, 2, 2])

参考

机器学习基础（11）条件随机场的理解及BI-LSTM+CRF实战
CRF Layer on the Top of BiLSTM