NLP-信息抽取-NER-2015-BiLSTM+CRF（二）：损失函数【BiLSTM+CRF模型适用于：中文分词、词性标注、命名实体识别】

冷不防 2023-10-01 16:58 26阅读 0赞

中文分词、命名实体识别、词性标注是自然语言理解中，基础性的工作，同时也是非常重要的工作。

在很多NLP的项目中，工作开始之前都要经过这三者中的一到多项工作的处理。

在深度学习中，有一种模型可以同时胜任这三种工作，而且效果还很不错，那就是：BiLSTM\_CRF。

*  BiLSTM指的是双向LSTM；
 *  CRF指的是条件随机场。

以命名实体识别为例，我们规定：

*  在数据集中有两类实体，人名和组织机构名称。
 *  在数据集中总共有5类标签：
    
     *  B-Person （人名的开始部分）
     *  I- Person （人名的中间部分）
     *  B-Organization （组织机构的开始部分）
     *  I-Organization （组织机构的中间部分）
     *  O （非实体信息）

此外，假设  x x x 是包含了5个单词的一句话 ( w 0 w\_0 w0, w 1 w\_1 w1, w 2 w\_2 w2, w 3 w\_3 w3, w 4 w\_4 w4)。在句子  x x x 中：

*  \[ w 0 w\_0 w0, w 1 w\_1 w1\]是人名；
 *  \[ w 3 w\_3 w3\] 是组织机构名称；
 *  其他都是“O”；

## 一、BiLSTM-CRF 模型 ##

如下图所示：  
![在这里插入图片描述][cf2376e03ef04c29b4a7d7a6b4825691.png_pic_center]

*  首先，句中的每个单词是一条包含词嵌入（word embedding）和字嵌入（character embedding）的**词向量**（vector ），词嵌入（word embedding）通常是事先训练好的，字嵌入（character embedding）则是随机初始化的。所有的嵌入（embedding）都会随着训练的迭代过程被调整。
 *  其次，BiLSTM-CRF的输入是词向量（vector），输出是句子  x x x 中每个单词对应的预测标签。

如下图所示，我们现在没有必要了解BiLSTM模型内部的细节，我们把注意力放在：

*  BiLSTM层的输出；
 *  CRF层；

![在这里插入图片描述][4a7957390b8c450abeccacf28405b2d5.png_pic_center]

BiLSTM层的输出表示该单词对应各个类别的分数。如对于  w 0 w\_0 w0，BiLSTM节点的输出是1.5 (B-Person), 0.9 (I-Person), 0.1 (B-Organization), 0.08 (I-Organization) and 0.05 (O)。这些分数将会是CRF层的输入。 所有的经BiLSTM层输出的分数将作为CRF层的输入，在CRF层输出的**所有类别序列**中分数最高的**类别序列**就是我们预测的最终结果。

## 二、如果没有CRF层会是什么样 ##

即使没有CRF层，我们照样可以训练一个基于BiLSTM的命名实体识别模型，如下图所示。

![在这里插入图片描述][ddaea25eae4e405b89f431c9424ea6df.png_pic_center]  
因为BiLSTM层的结果是单词对应各类别的分数，我们可以选择分数最高的类别作为预测结果。如：

*   w 0 w\_0 w0，“B-Person”的分数最高（1.5），那么我们可以选定“B-Person”作为预测结果；
 *   w 1 w\_1 w1 是“I-Person”；
 *   w 2 w\_2 w2是“O”；
 *   w 3 w\_3 w3是 “B-Organization” ；
 *   w 4 w\_4 w4是 “O”；

尽管我们在该例子中句子  x x x 得到了正确的结果，但实际情况并不总是这样：  
![在这里插入图片描述][fbaee480315c42998e76933fe72863d7.png_pic_center]  
显然，这次的分类结果并不准确。 “I-Organization I-Person” 和 “B-Organization I-Person”都是错误的。

## 三、CRF层可以学习到句子的约束条件 ##

CRF层可以加入一些约束来保证最终预测结果是有效的。这些约束可以在训练数据时被CRF层自动学习得到。

可能的约束条件有：

*  句子的开头应该是“B-”或“O”，而不是“I-”。
 *  “B-label1 I-label2 I-label3…”，在该模式中，类别1,2,3应该是同一种实体类别。比如，“B-Person I-Person” 是正确的，而“B-Person I-Organization”则是错误的。
 *  “O I-label”是错误的，命名实体的开头应该是“B-”而不是“I-”。
 *  …

有了这些有用的约束，错误的预测序列将会大大减少。

## 四、CRF 层 ##

CRF层中的损失函数包括两种类型的分数，而理解这两类分数的计算是理解CRF的关键。

### 1、Emission score（发射分数） ###

第一个类型的分数是发射分数（状态分数）。这些状态分数来自BiLSTM层的输出，在这里就是word预测为某个标签的概率。

如下图所示， w 0 w\_0 w0 被预测为B-Person的分数是1.5.

![在这里插入图片描述][9052f8282a7a407c9d22e3b165c4465f.png_pic_center]  
为方便起见，我们给每个类别一个索引，如下表所示：  
![在这里插入图片描述][0406b8ac7b3844f0a2e575b5842c8781.png_pic_center]  
 x i y j x\_\{iy\_j\} xiyj 代表状态分数， i i i 是单词的位置索引， y j y\_j yj 是类别的索引。

根据上表

x i = 1 , y j = 2 = x w 1 , B − O r g a n i z a t i o n = 0.1 x\_\{i=1,y\_j=2\} = x\_\{w\_1,B-Organization\} = 0.1 xi=1,yj=2=xw1,B−Organization=0.1

表示单词  w 1 w\_1 w1 被预测为B−Organization的分数是0.1。

### 2、Transition score（转移分数） ###

用  t y i y j t\_\{y\_iy\_j\} tyiyj 来表示转移分数。例如，  t B − P e r s o n , I − P e r s o n = 0.9 t\_\{B-Person, I-Person\} = 0.9 tB−Person,I−Person=0.9 表示从类别  B − P e r s o n → I − P e r s o n B-Person \\rightarrow I-Person B−Person→I−Person 的分数是0.9。因此，有一个所有类别间的转移分数矩阵。

为了使转移分数矩阵更具鲁棒性，我们加上START 和 END两类标签：

*  START代表一个句子的开始（不是句子的第一个单词）；
 *  END代表一个句子的结束；

下表是加上START和END标签的转移分数矩阵。

![在这里插入图片描述][95e41d8cc703411a90fa1f964c22c50d.png_pic_center]  
如上表格所示，转移矩阵已经学习到一些有用的约束条件：

*  句子的第一个单词应该是“B-” 或 “O”，而不是“I”。（从“START”->“I-Person 或 I-Organization”的转移分数很低）
 *  “B-label1 I-label2 I-label3…”，在该模式中，类别1,2,3应该是同一种实体类别。比如，“B-Person I-Person” 是正确的，而“B-Person I-Organization”则是错误的。（“B-Organization” -> “I-Person”的分数很低）
 *  “O I-label”是错误的，命名实体的开头应该是“B-”而不是“I-”。

**要怎样得到这个转移矩阵呢？**

实际上，转移矩阵是BiLSTM-CRF模型的一个参数。在训练模型之前，你可以随机初始化转移矩阵的分数。这些分数将随着训练的迭代过程被更新，换句话说，CRF层可以自己学到这些约束条件。

## 五、CRF损失函数 ##

CRF损失函数由两部分组成：

*  真实路径的分数 ；
 *  所有路径的总分数；

真实路径的分数应该是所有路径中分数最高的。

例如，数据集中有如下几种类别：  
![在这里插入图片描述][5f0e725595fa41f3a660feb3f28d038c.png_pic_center]  
一个包含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 P\_\{i\} Pi，共有N条路径，则路径的总分是：  
 P t o t a l = P 1 + P 2 + … + P N = e S 1 + e S 2 + … + e S N P\_\{total\} = P\_1 + P\_2 + … + P\_N = e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\} Ptotal=P1\+P2\+…\+PN=eS1\+eS2\+…\+eSN

其中  e e e 是常数  e e e。

如果第（10）条路径是真实路径，也就是说第十条是正确预测结果，那么第十条路径的分数应该是所有可能路径里得分最高的。

根据如下损失函数，在训练过程中，BiLSTM-CRF模型的参数值将随着训练过程的迭代不断更新，使得真实路径所占的比值越来越大。

L o s s F u n c t i o n = P R e a l P a t h P 1 + P 2 + … + P N = e S R e a l P a t h e S 1 + e S 2 + … + e S N = 真 实 路 径 分 数 所 有 可 能 的 路 径 的 总 分 Loss Function = \\cfrac\{P\_\{RealPath\}\}\{P\_1 + P\_2 + … + P\_N\}=\\cfrac\{e^\{S\_\{RealPath\}\}\}\{e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\}\}=\\cfrac\{真实路径分数\}\{所有可能的路径的总分\} LossFunction=P1\+P2\+…\+PNPRealPath=eS1\+eS2\+…\+eSNeSRealPath=所有可能的路径的总分真实路径分数

现在的问题是：

1.  怎么定义路径的分数？
2.  怎么计算所有路径的总分？
3.  当计算所有路径总分时，是否需要列举出所有可能的路径？（答案是不需要）

### 1、真实路径分数 ###

计算真实路径分数，  e S R e a l P a t h e^\{S\_\{RealPath\}\} eSRealPath，是非常容易的。

我们先集中注意力来计算  S R e a l P a t h S\_\{RealPath\} SRealPath：

以“**START B-Person I-Person O B-Organization O END**”这条真实路径来说：

*  句子中有5个单词，  w 1 , w 2 , w 3 , w 4 , w 5 w\_1, w\_2, w\_3, w\_4, w\_5 w1,w2,w3,w4,w5；
 *  加上START和END 在句子的开始位置和结束位置，记为， w 0 , w 6 w\_0, w\_6 w0,w6

S R e a l P a t h S\_\{RealPath\} SRealPath 包括2部分:  S R e a l P a t h = E m i s s i o n S c o r e + T r a n s i t i o n S c o r e S\_\{RealPath\} = EmissionScore + TransitionScore SRealPath=EmissionScore\+TransitionScore

*  **Emission score（发射分数）**： E m i s s i o n S c o r e = x 0 , S T A R T + x 1 , B − P e r s o n + x 2 , I − P e r s o n + x 3 , O + x 4 , B − O r g a n i z a t i o n + x 5 , O + x 6 , E N D \\begin\{aligned\}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\}\\end\{aligned\} EmissionScore=x0,START\+x1,B−Person\+x2,I−Person\+x3,O\+x4,B−Organization\+x5,O\+x6,END
    
     *   x i n d e x , l a b e l x\_\{index,label\} xindex,label 表示第  i n d e x t h index^\{th\} indexth 个单词标记为标签  l a b e l label label的分数；
     *   x 1 , B − P e r s o n x\_\{1,B-Person\} x1,B−Person、 x 2 , I − P e r s o n x\_\{2,I-Person\} x2,I−Person、  x 3 , O x\_\{3,O\} x3,O、  x 4 , O r g a n i z a t i o n x\_\{4,Organization\} x4,Organization、  x 5 , O x\_\{5,O\} x5,O 这些分数来自前面的 BiLSTM的输出；
     *   x 0 , S T A R T x\_\{0,START\} x0,START、 x 6 , E N D x\_\{6,END\} x6,END 可以直接设置为0；
 *  **Transition score（转移分数）**  
     T r a n s i t i o n S c o r e = t S T A R T − > B − P e r s o n + t B − P e r s o n − > I − P e r s o n + t I − P e r s o n − > O + t O − > B − O r g a n i z a t i o n + t B − O r g a n i z a t i o n − > O + t O − > E N D \\begin\{aligned\}TransitionScore=t\_\{START->B-Person\}+ t\_\{B-Person->I-Person\}+t\_\{I-Person->O\}+ t\_\{O->B-Organization\}+ t\_\{B-Organization->O\}+ t\_\{O->END\}\\end\{aligned\} TransitionScore=tSTART−>B−Person\+tB−Person−>I−Person\+tI−Person−>O\+tO−>B−Organization\+tB−Organization−>O\+tO−>END
    
     *   t l a b e l 1 − > l a b e l 2 t\_\{label1->label2\} tlabel1−>label2 是从  l a b e l 1 label1 label1 转移到  l a b e l 2 label2 label2 的转移分数；
     *   t S T A R T − > B − P e r s o n t\_\{START->B-Person\} tSTART−>B−Person、 t B − P e r s o n − > I − P e r s o n t\_\{B-Person->I-Person\} tB−Person−>I−Person、 t I − P e r s o n − > O t\_\{I-Person->O\} tI−Person−>O、 t O − > B − O r g a n i z a t i o n t\_\{O->B-Organization\} tO−>B−Organization、 t B − O r g a n i z a t i o n − > O t\_\{B-Organization->O\} tB−Organization−>O、 t O − > E N D t\_\{O->END\} tO−>END 这些转移分数都来自CRF层，换句话说，这些 transition 分数实际上是 CRF 层的参数。

综上所述，现在我们可以计算出  S R e a l P a t h S\_\{RealPath\} SRealPath 以及路径得分  e S R e a l P a t h e^\{S\_\{RealPath\}\} eSRealPath

### 2、所有可能的路径的总分 ###

如何计算所有路径的总分呢？

P t o t a l = P 1 + P 2 + … + P N = e S 1 + e S 2 + … + e S N P\_\{total\} = P\_1 + P\_2 + … + P\_N = e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\} Ptotal=P1\+P2\+…\+PN=eS1\+eS2\+…\+eSN

衡量总分最简单的方法是：列举所有可能的路径并将它们的分数相加。是的，你可以用这种方法计算总分。然而，这是非常低效的。训练的时间将是难以忍受的。

下面我们将会通过一个简单的例子，如何逐步计算一个句子的所有可能的路径的总分。

#### 2.1 步骤1: 回想一下CRF损失函数 ####

之前，我们将CRF损失函数定义为：

L o s s F u n c t i o n = P R e a l P a t h P 1 + P 2 + … + P N Loss Function = \\cfrac\{P\_\{RealPath\}\}\{P\_1 + P\_2 + … + P\_N\} LossFunction=P1\+P2\+…\+PNPRealPath

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

L o g L o s s F u n c t i o n = log ⁡ P R e a l P a t h P 1 + P 2 + … + P N LogLossFunction = \\log \\cfrac\{P\_\{RealPath\}\}\{P\_1 + P\_2 + … + P\_N\} LogLossFunction=logP1\+P2\+…\+PNPRealPath

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

L o g L o s s F u n c t i o n = − log ⁡ P R e a l P a t h P 1 + P 2 + … + P N = − log ⁡ e S R e a l P a t h e S 1 + e S 2 + … + e S N = − ( log ⁡ ( e S R e a l P a t h ) − log ⁡ ( e S 1 + e S 2 + … + e S N ) ) = − ( S R e a l P a t h − log ⁡ ( e S 1 + e S 2 + … + e S N ) ) = − ( ∑ i = 1 N x i y i + ∑ i = 1 N − 1 t y i y i + 1 − log ⁡ ( e S 1 + e S 2 + … + e S N ) ) \\begin\{aligned\} Log Loss Function &= - \\log \\cfrac\{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\})) \\end\{aligned\} LogLossFunction=−logP1\+P2\+…\+PNPRealPath=−logeS1\+eS2\+…\+eSNeSRealPath=−(log(eSRealPath)−log(eS1\+eS2\+…\+eSN))=−(SRealPath−log(eS1\+eS2\+…\+eSN))=−(i=1∑Nxiyi\+i=1∑N−1tyiyi\+1−log(eS1\+eS2\+…\+eSN))

在上一节中，我们已经知道如何计算实际路径得分  S R e a l P a t h S\_\{RealPath\} SRealPath，现在我们需要找到一个有效的解决方案来计算： e S 1 + e S 2 + … + e S N e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\} eS1\+eS2\+…\+eSN

#### 2.2 步骤2: 回忆一下Emission和Transition得分 ####

为了简化，我们假设我们从这个句子中训练我们的模型：

*  它的长度只有 3:  x = \[ w 0 , w 1 , w 2 \] \\color\{red\}\{\\mathbf\{x\} = \[w\_0, w\_1, w\_2\]\} x=\[w0,w1,w2\]；
 *  此外，在我们的数据集中，我们有两个标签： L a b e l S e t = \{ l 1 , l 2 \} \\color\{red\}\{LabelSet = \\\{l\_1,l\_2\\\}\} LabelSet=\{ l1,l2\}；
 *  我们还有 Bi-LSTM 层输出的 Emission 分数：  
    ![在这里插入图片描述][7de50d3c13324935b2f8fc854043333a.png_pic_center]  
    其中： x i j x\_\{ij\} xij 表示  w i w\_i wi 被标记为  l j l\_j lj 的得分（发射概率）。
 *  此外，Transition 分数来自 CRF 层：  
    ![在这里插入图片描述][4ceea82abfec4a7c8f368e2666ef4a30.png_pic_center]  
    其中： t i , j t\_\{i,j\} ti,j 是从标签  i i i 到标签  j j j 的 transition 得分（转移概率）。

#### 2.3 步骤3: 开始计算 ####

我们的目标是计算： log ⁡ ( e S 1 + e S 2 + … + e S N ) \\color\{red\}\{\\log(e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\})\} log(eS1\+eS2\+…\+eSN)

这个过程就是分数的累加。其思想与动态规划相似。我将逐步解释这个例子。简而言之：

*  计算  w 0 w\_0 w0 的所有可能路径的总分。
 *  然后，我们用总分来计算  w 0 → w 1 w\_0→w\_1 w0→w1。
 *  最后，我们使用最新的总分来计算  w 0 → w 1 → w 2 w\_0→w\_1→w\_2 w0→w1→w2。
 *  我们需要的是最后的总分。

在接下来的步骤中，你将看到两个变量：obs 和 previous：

*  previous 存储前面步骤的最终结果；
 *  obs 表示当前单词的信息；

--------------------

w 0 w\_0 w0:

p r e v i o u s = N o n e previous = None previous=None  
 o b s = \[ x 01 , x 02 \] obs = \[x\_\{01\}, x\_\{02\}\] obs=\[x01,x02\]

如果我们的句子只有一个单词  w 0 w\_0 w0，我们就没有前面步骤的结果，因此previous是None。另外，我们只能观察到第一个词  o b s = \[ x 01 , x 02 \] obs = \[x\_\{01\}, x\_\{02\}\] obs=\[x01,x02\]。 x 01 x\_\{01\} x01 和  x 02 x\_\{02\} x02 是上述的Emission分数。

你可能会想， w 0 w\_0 w0 的所有可能路径的总分是多少？答案很简单：

T o t a l S c o r e ( w 0 ) = log ⁡ ( e x 01 + e x 02 ) TotalScore(w\_0)=\\log (e^\{x\_\{01\}\} + e^\{x\_\{02\}\}) TotalScore(w0)=log(ex01\+ex02)

--------------------

w 0 → w 1 w\_0→w\_1 w0→w1

p r e v i o u s = \[ x 01 , x 02 \] previous = \[x\_\{01\}, x\_\{02\}\] previous=\[x01,x02\]  
 o b s = \[ x 11 , x 12 \] obs = \[x\_\{11\}, x\_\{12\}\] obs=\[x11,x12\]

1). 把previous展开成： p r e v i o u s = ( x 01 x 01 x 02 x 02 ) previous =\\left( \\begin\{matrix\} x\_\{01\}&x\_\{01\}\\\\x\_\{02\}&x\_\{02\} \\end\{matrix\} \\right) previous=(x01x02x01x02)

2). 把obs展开成： o b s = ( x 11 x 12 x 11 x 12 ) obs =\\left( \\begin\{matrix\} x\_\{11\}&x\_\{12\}\\\\ x\_\{11\}&x\_\{12\} \\end\{matrix\} \\right) obs=(x11x11x12x12)

你可能想知道，为什么我们需要把previous和obs扩展成矩阵。因为矩阵可以提高计算的效率。在下面的过程中，你将很快看到这一点。

3). 对 previous, obs以及transition得分求和：

s c o r e s = ( x 01 x 01 x 02 x 02 ) + ( x 11 x 12 x 11 x 12 ) + ( t 11 t 12 t 21 t 22 ) = ( x 01 + x 11 + t 11 x 01 + x 12 + t 12 x 02 + x 11 + t 21 x 02 + x 12 + t 22 ) 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)=\\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) scores=(x01x02x01x02)\+(x11x11x12x12)\+(t11t21t12t22)=(x01\+x11\+t11x02\+x11\+t21x01\+x12\+t12x02\+x12\+t22)

为下一个迭代，修改previous的值：

p r e v i o u s = \[ 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 ) \] 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\}\})\] previous=\[log(ex01\+x11\+t11\+ex02\+x11\+t21),log(ex01\+x12\+t12\+ex02\+x12\+t22)\]

实际上，第二次迭代已经完成。

如果有人想知道如何计算所有可能路径的总分 （ l a b e l 1 → l a b e l 1 , l a b e l 1 → l a b e l 2 , l a b e l 2 → l a b e l 1 , l a b e l 2 → l a b e l 2 label\_1 → label\_1, label\_1 → label\_2, label\_2 → label\_1, label\_2 → label\_2 label1→label1,label1→label2,label2→label1,label2→label2）

从 w 0 w\_0 w0 到  w 1 w\_1 w1，可以做如下计算。

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

T o t a l S c o r e ( w 0 → w 1 ) = log ⁡ ( e p r e v i o u s \[ 0 \] + e p r e v i o u s \[ 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 ) \\begin\{aligned\} 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\}\}) \\end\{aligned\} TotalScore(w0→w1)=log(eprevious\[0\]\+eprevious\[1\])=log(elog(ex01\+x11\+t11\+ex02\+x11\+t21)\+elog(ex01\+x12\+t12\+ex02\+x12\+t22))=log(ex01\+x11\+t11\+ex02\+x11\+t21\+ex01\+x12\+t12\+ex02\+x12\+t22)

你发现了吗？这正是我们的目标： log ⁡ ( e S 1 + e S 2 + … + e S N ) \\log(e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\}) log(eS1\+eS2\+…\+eSN)

在这个等式中，我们可以看到：

*   S 1 = x 01 + x 11 + t 11 S\_1 = x\_\{01\}+x\_\{11\}+t\_\{11\} S1=x01\+x11\+t11
 *   S 2 = x 02 + x 11 + t 21 S\_2 = x\_\{02\}+x\_\{11\}+t\_\{21\} S2=x02\+x11\+t21
 *   S 3 = x 01 + x 12 + t 12 S\_3 = x\_\{01\}+x\_\{12\}+t\_\{12\} S3=x01\+x12\+t12
 *   S 4 = x 02 + x 12 + t 22 S\_4 = x\_\{02\}+x\_\{12\}+t\_\{22\} S4=x02\+x12\+t22

--------------------

w 0 → w 1 → w 2 w\_0 → w\_1 → w\_2 w0→w1→w2：

如果你读到这里了，你已经快要读完了，实际上，在这个迭代里，我们做的事情是和上个迭代一样的。

1). 把previous扩展成： p r e v i o u s = ( 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 ) ) 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) previous=(log(ex01\+x11\+t11\+ex02\+x11\+t21)log(ex01\+x12\+t12\+ex02\+x12\+t22)log(ex01\+x11\+t11\+ex02\+x11\+t21)log(ex01\+x12\+t12\+ex02\+x12\+t22))

2). 把obs扩展成： o b s = ( x 21 x 22 x 21 x 22 ) obs =\\left( \\begin\{matrix\} x\_\{21\}&x\_\{22\}\\\\ x\_\{21\}&x\_\{22\} \\end\{matrix\} \\right) obs=(x21x21x22x22)

3). 把previous, obs和transition分数加起来

s c o r e s = ( 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 ) ) + ( x 21 x 22 x 21 x 22 ) + ( t 11 t 12 t 21 t 22 ) = ( 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 ) \\begin\{aligned\} 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)\\\\\[3ex\] &=\\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) \\end\{aligned\} scores=(log(ex01\+x11\+t11\+ex02\+x11\+t21)log(ex01\+x12\+t12\+ex02\+x12\+t22)log(ex01\+x11\+t11\+ex02\+x11\+t21)log(ex01\+x12\+t12\+ex02\+x12\+t22))\+(x21x21x22x22)\+(t11t21t12t22)=(log(ex01\+x11\+t11\+ex02\+x11\+t21)\+x21\+t11log(ex01\+x12\+t12\+ex02\+x12\+t22)\+x21\+t21log(ex01\+x11\+t11\+ex02\+x11\+t21)\+x22\+t12log(ex01\+x12\+t12\+ex02\+x12\+t22)\+x22\+t22)

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

p r e v i o u s = \[ 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 ) \] \\begin\{aligned\} 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\}\})\] \\end\{aligned\} previous=\[=\[log(elog(ex01\+x11\+t11\+ex02\+x11\+t21)\+x21\+t11\+elog(ex01\+x12\+t12\+ex02\+x12\+t22)\+x21\+t21),log(elog(ex01\+x11\+t11\+ex02\+x11\+t21)\+x22\+t12\+elog(ex01\+x12\+t12\+ex02\+x12\+t22)\+x22\+t22)\]log((ex01\+x11\+t11\+ex02\+x11\+t21)ex21\+t11\+(ex01\+x12\+t12\+ex02\+x12\+t22)ex21\+t21),log((ex01\+x11\+t11\+ex02\+x11\+t21)ex22\+t12\+(ex01\+x12\+t12\+ex02\+x12\+t22)ex22\+t22)\]

就像上一个迭代描述的一样，我们使用新的previous中的元素来计算总分数：

T o t a l S c o r e ( w 0 → w 1 → w 2 ) = log ⁡ ( e p r e v i o u s \[ 0 \] + e p r e v i o u s \[ 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 ) \\begin\{aligned\} 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\}\}) \\end\{aligned\} TotalScore(w0→w1→w2)=log(eprevious\[0\]\+eprevious\[1\])=log(elog((ex01\+x11\+t11\+ex02\+x11\+t21)ex21\+t11\+(ex01\+x12\+t12\+ex02\+x12\+t22)ex21\+t21)\+elog((ex01\+x11\+t11\+ex02\+x11\+t21)ex22\+t12\+(ex01\+x12\+t12\+ex02\+x12\+t22)ex22\+t22))=log(ex01\+x11\+t11\+x21\+t11\+ex02\+x11\+t21\+x21\+t11\+ex01\+x12\+t12\+x21\+t21\+ex02\+x12\+t22\+x21\+t21\+ex01\+x11\+t11\+x22\+t12\+ex02\+x11\+t21\+x22\+t12\+ex01\+x12\+t12\+x22\+t22\+ex02\+x12\+t22\+x22\+t22)

我们达到了目标， log ⁡ ( e S 1 + e S 2 + … + e S N ) \\log(e^\{S\_1\} + e^\{S\_2\} + … + e^\{S\_N\}) log(eS1\+eS2\+…\+eSN)。

我们的句子有三个单词，label set有两个label，所以一共应该有8种可能的label path。

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

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

在前面的章节中，我们学习了**BiLSTM-CRF模型的结构**和**CRF损失函数的细节**。你可以通过各种开源框架(Keras、TensorFlow、pytorch等)实现自己的BiLSTM-CRF模型。

最重要的事情之一是模型的反向传播是在这些框架上自动计算的，因此你不需要自己实现反向传播来训练你的模型(即计算梯度和更新参数)。此外，一些框架已经实现了CRF层，因此将CRF层与你自己的模型结合起来非常容易，只需添加一行代码即可。

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

### 1、步骤1：BiLSTM-CRF模型的Emission和transition得分 ###

假设，我们有一个包含三个单词的句子： x = \[ w 0 , w 1 , w 2 \] \\mathbf\{x\} = \[w\_0, w\_1, w\_2\] x=\[w0,w1,w2\]

此外，我们已经从BiLSTM模型得到了Emission分数，从下面的CRF层得到了transition分数：  
![在这里插入图片描述][673a49fedd84485c8fdb42c588f65981.png_pic_center]  
其中： x i j x\_\{ij\} xij 表示  w i w\_i wi 被标记为  l j l\_j lj 的得分（发射概率）。

![在这里插入图片描述][4ceea82abfec4a7c8f368e2666ef4a30.png_pic_center]  
其中： t i , j t\_\{i,j\} ti,j 是从标签  i i i 到标签  j j j 的 transition 得分（转移概率）。

### 2、步骤2：开始推断（Viterbi算法） ###

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

*   w 0 w\_0 w0
 *   w 0 → w 1 w\_0 → w\_1 w0→w1
 *   w 0 → w 1 → w 2 w\_0 → w\_1 → w\_2 w0→w1→w2

你会看到两个变量：obs和previous：

*  previous存储前面步骤的最终结果；
 *  obs表示当前单词的信息；
 *   a l p h a 0 \\mathbf\{alpha\_0\} alpha0 是历史最好得分；
 *   a l p h a 1 \\mathbf\{alpha\_1\} alpha1 是历史对应的索引;

--------------------

w 0 w\_0 w0:

p r e v i o u s = N o n e previous = None previous=None  
 o b s = \[ x 01 , x 02 \] obs = \[x\_\{01\}, x\_\{02\}\] obs=\[x01,x02\]

现在，我们观察第一个单词 w\_\{0\}，目前为止， w 0 w\_0 w0 最好的标签是很明显的。

比如，如果  o b s = \[ x 01 = 0.2 , x 02 = 0.8 \] obs = \[x\_\{01\}=0.2, x\_\{02\}=0.8\] obs=\[x01=0.2,x02=0.8\]，很显然， w 0 w\_0 w0 的最佳的标签是l2。

因为只有一个单词，而且没有标签直接的转换，transition的得分没有用到。

--------------------

w 0 → w 1 w\_0 → w\_1 w0→w1:

p r e v i o u s = \[ x 01 , x 02 \] previous = \[x\_\{01\}, x\_\{02\}\] previous=\[x01,x02\]  
 o b s = \[ x 11 , x 12 \] obs = \[x\_\{11\}, x\_\{12\}\] obs=\[x11,x12\]

1). 把previous扩展成： p r e v i o u s = ( p r e v i o u s \[ 0 \] p r e v i o u s \[ 0 \] p r e v i o u s \[ 1 \] p r e v i o u s \[ 1 \] ) = ( x 01 x 01 x 02 x 02 ) 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) previous=(previous\[0\]previous\[1\]previous\[0\]previous\[1\])=(x01x02x01x02)

2). 把obs扩展成： o b s = ( o b s \[ 0 \] o b s \[ 1 \] o b s \[ 0 \] o b s \[ 1 \] ) = ( x 11 x 12 x 11 x 12 ) 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) obs=(obs\[0\]obs\[0\]obs\[1\]obs\[1\])=(x11x11x12x12)

3). 把previous, obs和transition 分数都加起来：

s c o r e s = ( x 01 x 01 x 02 x 02 ) + ( x 11 x 12 x 11 x 12 ) + ( t 11 t 12 t 21 t 22 ) = ( x 01 + x 11 + t 11 x 01 + x 12 + t 12 x 02 + x 11 + t 21 x 02 + x 12 + t 22 ) \\begin\{aligned\} 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) =\\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) \\end\{aligned\} scores=(x01x02x01x02)\+(x11x11x12x12)\+(t11t21t12t22)=(x01\+x11\+t11x02\+x11\+t21x01\+x12\+t12x02\+x12\+t22)

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

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

p r e v i o u s = \[ max ⁡ ( s c o r e s \[ 00 \] , s c o r e s \[ 10 \] ) , max ⁡ ( s c o r e s \[ 01 \] , s c o r e s \[ 11 \] ) \] previous=\[\\max (scores\[00\], scores\[10\]),\\max (scores\[01\],scores\[11\])\] previous=\[max(scores\[00\],scores\[10\]),max(scores\[01\],scores\[11\])\]

比如，如果我们的得分是：

s c o r e s = ( x 01 + x 11 + t 11 x 01 + x 12 + t 12 x 02 + x 11 + t 21 x 02 + x 12 + t 22 ) = ( 0.2 0.3 0.5 0.4 ) 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) scores=(x01\+x11\+t11x02\+x11\+t21x01\+x12\+t12x02\+x12\+t22)=(0.20.50.30.4)

我们的下个迭代的previous是：

p r e v i o u s = \[ max ⁡ ( s c o r e s \[ 00 \] , s c o r e s \[ 10 \] ) , max ⁡ ( s c o r e s \[ 01 \] , s c o r e s \[ 11 \] ) \] = \[ 0.5 , 0.4 \] previous=\[\\max (scores\[00\], scores\[10\]),\\max (scores\[01\],scores\[11\])\] = \[0.5, 0.4\] previous=\[max(scores\[00\],scores\[10\]),max(scores\[01\],scores\[11\])\]=\[0.5,0.4\]

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

\[Example Start\]  
举个例子：我们知道在我们的语料中，我们总共只有2个标签， l a b e l 1 ( l 1 ) label1(l\_1) label1(l1) 和  l a b e l 2 ( l 2 ) label2(l\_2) label2(l2)。这两个标签的索引分别是0和1(因为在程序中index从0开始而不是1)。 p r e v i o u s \[ 0 \] previous\[0\] previous\[0\]是以第0个标签  l 1 l\_1 l1 为结尾的路径的最大得分，类似的  p r e v i o u s \[ 1 \] previous\[1\] previous\[1\] 是以第1个标签 l 2 l\_2 l2 为结尾的路径的最大得分。**在每个迭代中，变量previous存储了以每个标签为结尾的路径的最大得分。换句话说，在每个迭代中，我们只保留了每个标签的最佳路径的信息** （ p r e v i o u s = \[ m a x ( s c o r e s \[ 00 \] , s c o r e s \[ 10 \] ) , m a x ( s c o r e s \[ 01 \] , s c o r e s \[ 11 \] ) \] previous=\[max(scores\[00\],scores\[10\]),max(scores\[01\],scores\[11\])\] previous=\[max(scores\[00\],scores\[10\]),max(scores\[01\],scores\[11\])\]），具有小得分的路径信息会被丢掉。  
\[Example End\]

回到我们的主任务：  
同时，我们还有两个变量用来存储历史信息（得分和索引）， a l p h a 0 alpha\_0 alpha0 和  a l p h a 1 alpha\_1 alpha1。  
在这个迭代中，我们把最佳得分放入  a l p h a 0 alpha\_0 alpha0，为了方便，每个标签的最大得分会加上下划线。

s c o r e s = ( x 01 + x 11 + t 11 x 01 + x 12 + t 12 x 02 + x 11 + t 21 ‾ x 02 + x 12 + t 22 ‾ ) = ( 0.2 0.3 0.5 ‾ 0.4 ‾ ) 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) scores=(x01\+x11\+t11x02\+x11\+t21x01\+x12\+t12x02\+x12\+t22)=(0.20.50.30.4)

a l p h a 0 = \[ ( s c o r e s \[ 10 \] , s c o r e s \[ 11 \] ) \] = \[ ( 0.5 , 0.4 ) \] alpha\_0=\[(scores\[10\],scores\[11\])\]=\[(0.5,0.4)\] alpha0=\[(scores\[10\],scores\[11\])\]=\[(0.5,0.4)\]

另外，对应的列的索引(当前词前一个词的状态的index)存在  a l p h a 1 alpha\_1 alpha1 里。

a l p h a 1 = \[ ( C o l u m n I n d e x ( s c o r e s \[ 10 \] ) , C o l u m n I n d e x ( s c o r e s \[ 11 \] ) ) \] = \[ ( 1 , 1 ) \] alpha\_1=\[(ColumnIndex(scores\[10\]),ColumnIndex(scores\[11\]))\]=\[(1,1)\] alpha1=\[(ColumnIndex(scores\[10\]),ColumnIndex(scores\[11\]))\]=\[(1,1)\]

说明一下， l 1 l\_1 l1 的索引是0， l 2 l\_2 l2 的索引是1，所以  ( 1 , 1 ) = ( l 2 , l 2 ) (1,1)=(l\_2,l\_2) (1,1)=(l2,l2) 表示,对于当前的单词  w i w\_i wi 和标签  l ( i ) l^\{(i)\} l(i)：

*  当路径是 l ( i − 1 ) = l 2 ‾ → l ( i ) = l 1 ‾ \\underline\{l^\{(i-1)\}=l\_2\}→\\underline\{l^\{(i)\}=l\_1\} l(i−1)=l2→l(i)=l1的时候，我们可以得到最大的得分是0.5；
 *  当路径是  l ( i − 1 ) = l 2 ‾ → l ( i ) = l 2 ‾ \\underline\{l^\{(i-1)\}=l\_2\}→\\underline\{l^\{(i)\}=l\_2\} l(i−1)=l2→l(i)=l2 的时候，我们可以得到最大的得分是0.4。
 *   l ( i − 1 ) l^\{(i-1)\} l(i−1) 是前一个单词  w i − 1 w\_\{i-1\} wi−1 的标签；

--------------------

w 0 → w 1 → w 2 w\_0 → w\_1 → w\_2 w0→w1→w2：

p r e v i o u s = \[ 0.5 , 0.4 \] previous = \[0.5, 0.4\] previous=\[0.5,0.4\]  
 o b s = \[ x 21 , x 22 \] obs = \[x\_\{21\}, x\_\{22\}\] obs=\[x21,x22\]

1). 把previous扩展成： p r e v i o u s = ( p r e v i o u s \[ 0 \] p r e v i o u s \[ 0 \] p r e v i o u s \[ 1 \] p r e v i o u s \[ 1 \] ) = ( 0.5 0.5 0.4 0.4 ) 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) previous=(previous\[0\]previous\[1\]previous\[0\]previous\[1\])=(0.50.40.50.4)

2). 把obs扩展成： o b s = ( o b s \[ 0 \] o b s \[ 1 \] o b s \[ 0 \] o b s \[ 1 \] ) = ( x 21 x 22 x 21 x 22 ) 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) obs=(obs\[0\]obs\[0\]obs\[1\]obs\[1\])=(x21x21x22x22)

3). 把previous, obs和transition 分数都加起来：

s c o r e s = ( 0.5 0.5 0.4 0.4 ) + ( x 21 x 22 x 21 x 22 ) + ( t 11 t 12 t 21 t 22 ) = ( 0.5 + x 11 + t 11 0.5 + x 12 + t 12 0.4 + x 11 + t 21 0.4 + x 12 + t 22 ) 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) =\\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) scores=(0.50.40.50.4)\+(x21x21x22x22)\+(t11t21t12t22)=(0.5\+x11\+t110.4\+x11\+t210.5\+x12\+t120.4\+x12\+t22)

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

假设这次迭代我们得到的分数是：

s c o r e s = ( 0.6 0.9 ‾ 0.8 ‾ 0.7 ) scores = \\left( \\begin\{matrix\} 0.6&\\underline\{0.9\}\\\\ \\underline\{0.8\}&0.7 \\end\{matrix\} \\right) scores=(0.60.80.90.7)

我们得到最新的previous：

p r e v i o u s = \[ 0.8 , 0.9 \] previous=\[0.8,0.9\] previous=\[0.8,0.9\]

实际上， p r e v i o u s \[ 0 \] previous\[0\] previous\[0\] 和  p r e v i o u s \[ 1 \] previous\[1\] previous\[1\] 中最大的那个就是预测的最佳路径。

同时，每个标签的最大分数和对应的索引会添加到  a l p h a 0 alpha\_0 alpha0上和  a l p h a 1 alpha\_1 alpha1 上。

a l p h a 0 = \[ ( 0.5 , 0.4 ) , ( s c o r e s \[ 10 \] , s c o r e s \[ 01 \] ) ‾ \] = \[ ( 0.5 , 0.4 ) , ( 0.8 , 0.9 ) ‾ \] alpha\_0=\[(0.5,0.4),\\underline\{(scores\[10\],scores\[01\])\}\]=\[(0.5,0.4),\\underline\{(0.8,0.9)\}\] alpha0=\[(0.5,0.4),(scores\[10\],scores\[01\])\]=\[(0.5,0.4),(0.8,0.9)\]

a l p h a 1 = \[ ( 1 , 1 ) , ( 1 , 0 ) ‾ \] alpha\_1=\[(1,1),\\underline\{(1,0)\}\] alpha1=\[(1,1),(1,0)\]

### 3、步骤3：找到具有最高得分的最佳路径 ###

这是最后一步,在此步骤中，将使用  a l p h a 0 alpha\_0 alpha0 和  a l p h a 1 alpha\_1 alpha1 来查找得分最高的路径。我们将从最后一个到第一个地去检查这两个列表中的元素。

w 1 → w 2 w\_1 → w\_2 w1→w2：

首先，检查  a l p h a 0 alpha\_0 alpha0 和  a l p h a 1 alpha\_1 alpha1 的最后一个元素： ( 0.8 , 0.9 ) (0.8,0.9) (0.8,0.9) 和  ( 1 , 0 ) (1,0) (1,0)。0.9表示当label为  l 2 l\_2 l2 时，我们可以得到最高的路径分数0.9。我们还知道  l 2 l\_2 l2 的索引是1，因此检查  ( 1 , 0 ) \[ 1 \] = 0 (1,0)\[1\]=0 (1,0)\[1\]=0 的值。索引“0”表示前一个标签为  l 1 l\_1 l1 ( l 1 l\_1 l1的索引为0)，因此我们可以得到  w 1 → w 2 w\_1 → w\_2 w1→w2 的最佳路径：是  l 1 → l 2 l\_1 → l\_2 l1→l2。

--------------------

w 0 → w 1 w\_0 → w\_1 w0→w1：  
然后，我们继续向回移动并从  a l p h a 1 alpha\_1 alpha1 中得到元素： ( 1 , 1 ) (1,1) (1,1)。从上一段我们知道  w 1 w\_1 w1 的label是  l 1 l\_1 l1 (index是0)，因此我们可以检查  ( 1 , 1 ) \[ 0 \] = 1 (1,1)\[0\]=1 (1,1)\[0\]=1。因此，我们可以得到这部分( w 0 → w 1 w\_0 → w\_1 w0→w1)的最佳路径:  l 2 → l 1 l\_2 → l\_1 l2→l1。

最后，我们这个例子中的最佳路径是  l 2 → l 1 → l 2 l\_2 → l\_1 → l\_2 l2→l1→l2。

## 七、pytorch实现 ##

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

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可能会对大家造成一点困扰，但其实这是一种考虑数值稳定性的求解办法，具体大家参考[这篇博文][Link 1]即可。

我们接着看模型的定义，  
其中：

*  self.transitions表示转移矩阵（待训练参数），大小为：`[tag_size, tag_size]`
    
        self.transitions =  Parameter containing:
        tensor([[ 0.6874,  1.7763, -0.7697,  0.8740,  0.4898, -0.1338, -0.0162],
                [-0.5895,  1.4677, -1.0780,  0.6424, -0.7042, -2.0270,  0.0166],
                [ 0.3082, -1.0703, -0.8651, -0.1435, -2.4416,  0.0158, -1.4867],
                [-0.7350, -0.2415, -0.4596, -0.6743,  0.8018,  0.4665, -0.1629],
                [-0.9718, -0.0127, -1.2812,  0.2758,  2.2395, -0.4329, -0.4420],
                [ 0.3810,  0.1020, -0.7206,  0.4145,  0.1312,  0.1685,  1.6218],
                [-1.0138,  1.1071, -1.4225, -0.3020,  0.5202, -0.0534,  0.6517]],
               requires_grad=True)
 *  feat\_line 表示长度为20的句子，每个word有7个可能的tag的概率分布（转移分数）；`feat_line.shape = torch.Size([20, 7]`
    
        feat_line = tensor([
        		[-0.0306,  0.0870,  0.0475,  0.1723,  0.2211, -0.0172, -0.1754],
                [ 0.0350,  0.1697,  0.0307,  0.2508, -0.2015,  0.0502, -0.1555],
                [ 0.1938,  0.0177,  0.0841,  0.1230, -0.0798, -0.0786,  0.0203],
                [ 0.2421, -0.0122, -0.0622,  0.1384, -0.1659,  0.0081,  0.0384],
                [-0.0576, -0.1146,  0.0373,  0.2071, -0.0659, -0.0516, -0.0608],
                [-0.0419,  0.1496, -0.0933,  0.1384, -0.0285,  0.0278, -0.0128],
                [-0.0442,  0.0960,  0.0308,  0.3154,  0.2339, -0.0574, -0.0333],
                [-0.0503,  0.0919,  0.1199,  0.2057,  0.0417,  0.1378, -0.2690],
                [-0.0571, -0.0838,  0.1876,  0.0771,  0.0536,  0.0848, -0.0442],
                [-0.0323, -0.0418,  0.3817,  0.2518, -0.0526,  0.1345, -0.1200],
                [-0.1203,  0.0167,  0.2106, -0.1168, -0.1848,  0.0581, -0.1278],
                [-0.1082, -0.0091, -0.0552, -0.0193, -0.0293, -0.0014, -0.0541],
                [-0.1279, -0.1956, -0.0020,  0.0715, -0.0017,  0.0195,  0.0664],
                [ 0.1777,  0.0965, -0.1087, -0.0721, -0.0254, -0.1726,  0.2019],
                [ 0.0145, -0.0338,  0.0423,  0.0314, -0.3293,  0.0381, -0.0530],
                [-0.2209, -0.2647,  0.1477,  0.1590, -0.0666,  0.1108, -0.0890],
                [-0.0634,  0.0080, -0.1450, -0.0087, -0.0891, -0.1427, -0.1494],
                [-0.0359,  0.0462,  0.1249, -0.1224,  0.0015, -0.1628, -0.0695],
                [-0.0416, -0.1597, -0.0939, -0.0718, -0.1514, -0.1202,  0.1584],
                [-0.2761, -0.2413,  0.0734, -0.0264, -0.0792, -0.1983,  0.0321]
                ], grad_fn=<UnbindBackward>)
 *  feat表示每个词在7个可能的tag的概率分布（发射分数）；`feat.shape = torch.Size([7])`
    
        feat = tensor([-0.0306,  0.0870,  0.0475,  0.1723,  0.2211, -0.0172, -0.1754], grad_fn=<UnbindBackward>)
 *  **emit\_score** 表示当前word在  t a g i tag\_i tagi 标签上的发射分数：`-0.0306`，扩展后（为了方便与trans\_score加和计算）：  
    `[ -0.0306, -0.0306, -0.0306, -0.0306, -0.0306, -0.0306, -0.0306]`；
 *  **trans\_score** 表示当前word的所有可能tag分别转移到  t a g i tag\_i tagi 标签上的转移分数：  
    `[ 0.6874, 1.7763, -0.7697, 0.8740, 0.4898, -0.1338, -0.0162]`；
 *  **log\_sum\_exp\_result** 表示当前word在 t a g i tag\_i tagi 标签上总分数；
 *  **alphas\_of\_this\_word**表示当前word在各个tag标签上的总分数；

# 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))
        
        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
    
        # 求log(e^s1 + e^s2 + e^s3 + ... + e^sN)的值
    	# 损失函数第一项的分值函数【本质上是发射概率矩阵和转移概率矩阵的所有元素值(概率值)得累加和】
        def _forward_alg(self, features):
            result = torch.zeros((1, self.batch_size))  # 初始化最终的结果张量, 每个句子对应一个分数
    
            # 初始概率矩阵
            init_alphas = torch.full((1, self.tag_size), -10000.)  # 初始化一个alphas张量, 代表"转移概率矩阵"的初始化概率值【init_alphas.shape = torch.Size([1, 7])----init_alphas = tensor([[-10000., -10000., -10000., -10000., -10000., -10000., -10000.]])】
            print("init_alphas.shape = {0}----init_alphas = {1}".format(init_alphas.shape, init_alphas))
            init_alphas[0][self.tag2id[START_TAG]] = 0.  # 仅仅把START_TAG赋值为0, 代表着接下来的转移只能从START_TAG开始 【init_alphas.shape = torch.Size([1, 7])----init_alphas = tensor([[-10000., -10000., -10000., -10000., -10000.,      0., -10000.]])】
            print("把START_TAG赋值为0后---->init_alphas.shape = {0}----init_alphas = {1}".format(init_alphas.shape, init_alphas))
    
            # 发射概率矩阵
            print("Embedding之后的输入---->features.shape = {0}".format(features.shape))  # features.shape = torch.Size([20, 8, 7])   20代表句子长度，8代表batch_size，7代表tag_size
            features = features.transpose(1, 0)  # 输入进来的features: [20, 8, 7], 为了接下来按句子进行计算, 要将batch_size放在第一个维度上【features: [8, 20, 7]是一个3维矩阵, 最外层代表8个句子, 内层代表每个句子有20个字符,每一个字符映射成7个标签的发射概率】
            print("将batch_size维度调整到最前面---->features.shape = {0}".format(features.shape))
    
            idx = 0
            forward_var = init_alphas  # 将初始化的 init_alphas 赋值给前向计算变量, 这样在反向求导的过程中就可以自动更新参数【forward_var.shape = torch.Size([1, 7])----初始化的：forward_var = tensor([[-10000., -10000., -10000., -10000., -10000.,      0., -10000.]])】
            print("初始化的---->forward_var.shape = {0}----shape = {1}".format(forward_var.shape, forward_var))
            for seq_idx, feat_line in enumerate(features):  # 按行遍历, 总共循环batch_size次【features:[8,20,7]; feat_line:[20,7]】
                print("-" * 50, "第 {0} 条句子，句子维度：feat_line.shape = {1}".format(seq_idx, feat_line.shape), "-" * 50)
                # 计算当前句子的概率score
                for word_index, feat in enumerate(feat_line):  # 遍历一行语句, 每一个feat代表一个time_step(一个汉字或符号)
                    print("第{0}句子的第{1}个词----feat.shape = {2}----feat = {3}".format(seq_idx, word_index, feat.shape, feat))
                    alphas_of_this_word = []  # 当前time_step(汉字或符号) 初始化一个前向计算张量
                    # 在当前time_step, ☆☆☆遍历所有可能的转移标签☆☆☆, 进行累加计算【self.tag_size = 7】
                    for next_tag_idx in range(self.tag_size):
                        emit_score = feat[next_tag_idx].view(1, -1).expand(1, self.tag_size)  # 由BiLSTM模块的输出：发射概率矩阵【torch.Size([1, 7])】【broadcast the emission score: it is the same regardless of(不管) the previous tag】
                        trans_score = self.transitions[next_tag_idx].view(1, -1)  # 第i个time_step循环时, 转移到next_tag_idx标签的转移概率【torch.Size([1, 7])】【the ith entry of trans_score is the score of transitioning to next_tag from i】
                        next_tag_var = forward_var + trans_score + emit_score  # 将前向矩阵, 转移矩阵, 发射矩阵累加【The ith entry of next_tag_var is the value for the edge (i -> next_tag) before we do log-sum-exp】
                        print("\tnext_tag_idx = {0}----next_tag_var = {1}".format(next_tag_idx, next_tag_var))
                        # 计算log_sum_exp()函数值，并添加到 alphas_of_this_word 列表中
                        log_sum_exp_result = log_sum_exp(next_tag_var).view(1)  # 注意: log_sum_exp()函数仅仅返回一个实数值【log_sum_exp_result.view(1)的操作就是将一个数字变成一个一阶矩阵, ([]) -> ([1])】
                        print("\tnext_tag_idx = {0}----log_sum_exp_result = {1}".format(next_tag_idx, log_sum_exp_result))
                        alphas_of_this_word.append(log_sum_exp_result) # The forward variable for this tag is log-sum-exp of all the scores
                    alphas_of_this_word = torch.cat(alphas_of_this_word).view(1, -1)  # 当前词汇的概率计算结果：alphas_of_this_word
                    print("当前句子的第{0}个词的概率分数---->alphas_of_this_word.shape = {1}----alphas_of_this_word = {2}".format(word_index, alphas_of_this_word.shape, alphas_of_this_word))
                    forward_var = alphas_of_this_word  # 将当前词汇的概率分数赋值给 forward_var
                print("\n", "=" * 10, "计算第 {0} 条句子的所有词汇的概率分数后，更新后的forward_var---->forward_var.shape = {1}----forward_var = {2}".format(seq_idx, forward_var.shape, forward_var))
                terminal_var = forward_var + self.transitions[self.tag2id[STOP_TAG]]  # 添加最后一步转移到"STOP_TAG"的分数, 就完成了整条语句的分数计算
                sentence_alpha = log_sum_exp(terminal_var)  # 计算log_sum_exp()函数值, 作为一条样本语句（一句文本）的最终得分
                print("\n", "=" * 10, "计算第 {0} 条句子的最终得分：sentence_alpha = {1}".format(seq_idx, sentence_alpha))
                result[0][idx] = sentence_alpha  # 将当前句子的最终得分添加到最终的结果列表中, 作为函数结果返回
                idx += 1
            print("\n\n", "=" * 10, "所有句子的最终得分列表：result = {0}".format(result))
            return result
    
       # 损失函数第二项的分值函数（在真实标签target_tags指导下的计算）
        def _score_sentence(self, features, target_tags):  # features: 经历了_get_lstm_output_features()处理后的特征张量，形状为：[20, 8, 7] , target_tags 代表训练语句真实的标签矩阵，形状: [8, 20]
            result = torch.zeros((1, self.batch_size))  # 初始化最终的结果分数张量, 每一个句子得到一个分数
    
            score = torch.zeros(1)  # 初始化一个0值的tensor, 为后续累加做准备
            temp = torch.full((self.batch_size, 1), self.tag2id[START_TAG]).clone().detach()
            print("损失函数第二项的分值函数---->temp.shape = {0}----temp = {1}".format(temp.shape, temp))
            target_tags = torch.cat((temp, target_tags), dim=1)  # 将START_TAG和真实标签 target_tags 做列维度上的拼接【在target_tags矩阵的第一列添加全部都是START_TAG的一列】
            print("损失函数第二项的分值函数---->target_tags.shape = {0}----target_tags = {1}".format(target_tags.shape, target_tags))
            features = features.transpose(1, 0)  # 将传入的features形状转变为[bathc_size, sentence_length, tag_size]
            print("损失函数第二项的分值函数---->将batch_size维度调整到最前面---->features.shape = {0}".format(features.shape))
    
            idx = 0
            for seq_idx, feat_line in enumerate(features):  # 按行遍历, 总共循环batch_size次【features:[8,20,7]; feat_line:[20,7]】
                print("损失函数第二项的分值函数---->第 {0} 条句子，句子维度：feat_line.shape = {1}".format(seq_idx, feat_line.shape), "-" * 50)
                # 遍历一行语句, 每一个feat代表一个time_step(一个汉字或符号)【注意: 此处区别于第三步的循环, 最重要的是☆☆☆这儿是在真实标签指导下的转移概率矩阵和发射概率矩阵的累加分数☆☆☆】
                for word_index, feat in enumerate(feat_line):
                    print("当前句子的第{0}个词----feat.shape = {1}----feat = {2}".format(word_index, feat.shape, feat))
                    target_tag_i = target_tags[idx][word_index + 1]
                    target_tag_j = target_tags[idx][word_index]
                    print("当前句子的第{0}个词----target_tag_i = {1}----target_tag_j = {2}".format(word_index, target_tag_i, target_tag_j))
                    feat_score = feat[target_tag_i]  # 发射概率矩阵的概率得分
                    print("当前句子的第{0}个词----feat_score = {1}".format(word_index, feat_score))
                    transition_score = self.transitions[target_tag_i, target_tag_j]  # 转移概率矩阵的概率得分
                    print("当前句子的第{0}个词----transition_score = {1}".format(word_index, transition_score))
                    current_score = transition_score + feat_score
                    score += current_score  # 累加3者：累加的前向概率得分矩阵, 当前的转移概率矩阵的概率得分, 当前的发射概率矩阵的概率得分
                    print("当前句子的第{0}个词----更新后的 score = {1}".format(word_index, score))
                print("\n", "损失函数第二项的分值函数---->第 {0} 条句子的最终得分：score = {1}".format(seq_idx, score))
                score = score + self.transitions[self.tag2id[STOP_TAG], target_tags[idx][-1]]  # 最遍历完当前语句所有的时间步之后，最后加上转移到STOP_TAG的分数
                print("损失函数第二项的分值函数---->加上转移到STOP_TAG的分数：第 {0} 条句子的最终得分：score = {1}".format(seq_idx, score))  # score = tensor([-80.6242], grad_fn=<AddBackward0>)
                result[0][idx] = score
                idx += 1
            print("\n\n", "=" * 10, "损失函数第二项的分值函数---->所有句子的最终得分列表：result = {0}".format(result))
            return result
    
        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

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

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])

--------------------

参考资料：  
[BiLSTM+CRF及pytorch实现 ][BiLSTM_CRF_pytorch_]  
[BiLSTM-CRF模型理解][BiLSTM-CRF]  
[BiLSTM上的CRF，用命名实体识别任务来解释CRF（1）][BiLSTM_CRF_CRF_1]  
[BiLSTM上的CRF，用命名实体识别任务来解释CRF（2）损失函数][BiLSTM_CRF_CRF_2]  
[BiLSTM +CRF 原理介绍][BiLSTM _CRF]  
[BiLSTM+CRF 的实现详解][BiLSTM_CRF]  
[BiLSTM 上的 CRF，用命名实体识别任务来解释 CRF（2）损失函数][BiLSTM _ CRF_ CRF_2]  
[BiLSTM+CRF学习笔记][BiLSTM_CRF 1]  
[（四十四）通俗易懂理解——BiLSTM-CRF][BiLSTM-CRF 1]  
[BiLSTM+CRF学习笔记][BiLSTM_CRF 1]  
[CRF Layer on the Top of BiLSTM - 1][]  
[CRF Layer on the Top of BiLSTM - 2][]  
[CRF Layer on the Top of BiLSTM - 3][]  
[CRF Layer on the Top of BiLSTM - 4][]  
[CRF Layer on the Top of BiLSTM - 5][]  
[CRF Layer on the Top of BiLSTM - 6][]

[cf2376e03ef04c29b4a7d7a6b4825691.png_pic_center]: https://img-blog.csdnimg.cn/cf2376e03ef04c29b4a7d7a6b4825691.png#pic_center
[4a7957390b8c450abeccacf28405b2d5.png_pic_center]: https://img-blog.csdnimg.cn/4a7957390b8c450abeccacf28405b2d5.png#pic_center
[ddaea25eae4e405b89f431c9424ea6df.png_pic_center]: https://img-blog.csdnimg.cn/ddaea25eae4e405b89f431c9424ea6df.png#pic_center
[fbaee480315c42998e76933fe72863d7.png_pic_center]: https://img-blog.csdnimg.cn/fbaee480315c42998e76933fe72863d7.png#pic_center
[9052f8282a7a407c9d22e3b165c4465f.png_pic_center]: https://img-blog.csdnimg.cn/9052f8282a7a407c9d22e3b165c4465f.png#pic_center
[0406b8ac7b3844f0a2e575b5842c8781.png_pic_center]: https://img-blog.csdnimg.cn/0406b8ac7b3844f0a2e575b5842c8781.png#pic_center
[95e41d8cc703411a90fa1f964c22c50d.png_pic_center]: https://img-blog.csdnimg.cn/95e41d8cc703411a90fa1f964c22c50d.png#pic_center
[5f0e725595fa41f3a660feb3f28d038c.png_pic_center]: https://img-blog.csdnimg.cn/5f0e725595fa41f3a660feb3f28d038c.png#pic_center
[7de50d3c13324935b2f8fc854043333a.png_pic_center]: https://img-blog.csdnimg.cn/7de50d3c13324935b2f8fc854043333a.png#pic_center
[4ceea82abfec4a7c8f368e2666ef4a30.png_pic_center]: https://img-blog.csdnimg.cn/4ceea82abfec4a7c8f368e2666ef4a30.png#pic_center
[673a49fedd84485c8fdb42c588f65981.png_pic_center]: https://img-blog.csdnimg.cn/673a49fedd84485c8fdb42c588f65981.png#pic_center
[Link 1]: https://www.cnblogs.com/zjuhaohaoxuexi/p/15264515.html
[BiLSTM_CRF_pytorch_]: https://www.cnblogs.com/zjuhaohaoxuexi/p/15257605.html
[BiLSTM-CRF]: https://blog.csdn.net/weixin_30352645/article/details/101847018
[BiLSTM_CRF_CRF_1]: https://blog.csdn.net/u011984148/article/details/105108876
[BiLSTM_CRF_CRF_2]: https://blog.csdn.net/u011984148/article/details/105154265
[BiLSTM _CRF]: https://www.cnblogs.com/ltolstar/p/11975937.html
[BiLSTM_CRF]: https://baijiahao.baidu.com/s?id=1668580710512239699&wfr=spider&for=pc
[BiLSTM _ CRF_ CRF_2]: https://www.6aiq.com/article/1585415235824
[BiLSTM_CRF 1]: https://www.jianshu.com/p/b7105bcbdf4f
[BiLSTM-CRF 1]: https://zhuanlan.zhihu.com/p/115053401
[CRF Layer on the Top of BiLSTM - 1]: https://createmomo.github.io/2017/09/12/CRF_Layer_on_the_Top_of_BiLSTM_1/
[CRF Layer on the Top of BiLSTM - 2]: https://createmomo.github.io/2017/09/23/CRF_Layer_on_the_Top_of_BiLSTM_2/
[CRF Layer on the Top of BiLSTM - 3]: https://createmomo.github.io/2017/10/08/CRF-Layer-on-the-Top-of-BiLSTM-3/
[CRF Layer on the Top of BiLSTM - 4]: https://createmomo.github.io/2017/10/17/CRF-Layer-on-the-Top-of-BiLSTM-4/
[CRF Layer on the Top of BiLSTM - 5]: https://createmomo.github.io/2017/11/11/CRF-Layer-on-the-Top-of-BiLSTM-5/
[CRF Layer on the Top of BiLSTM - 6]: https://createmomo.github.io/2017/11/24/CRF-Layer-on-the-Top-of-BiLSTM-6/