条件随机场CRF之从公式到代码

前言

基础的理论推导我就不再搬运了，网上有很多大大们写的都很好，但是我发现文章基本分成了两类，一类讲理论讲的特别好，但是缺少了与实际代码的结合；一类讲实践，主要是如何使用顺带提一下公式，主要是默认读者已经对公式烂熟于心了。所以我想做个桥梁，结合公式和代码实现把CRF捋一遍。对于理论还不是很熟的童鞋请参考文章最后的引用链接，讲的非常详细。文章中使用的代码来自于pytorch官方文档：https://pytorch.org/tutorials/beginner/nlp/advanced_tutorial.html

CRF实现细节

• 生成模型和判别式模型
  简单一点理解，生成模型就是根据数据集去建立联合概率分布$P(X,Y)$的模型，比如贝叶斯模型、HMM；判别式模式就是根据数据集中X和Y的对应关系去建立一个超平面用于分类，判别式模型的目的就是为了分类，比如SVM、神经网络。切记，切记HMM是生成模型而CRF是判别式模型！ 更详细的解释请参考https://zhuanlan.zhihu.com/p/33397147里的2.2节。

• 无向图的概率计算
  设有无向图，一般指马尔科夫网络,可以用因子分解将$P(Y)$ 写成若干个联合概率的乘积，这里的“若干个联合概率”是指将图分解成若干个最大团的乘积。比如下图中可以分解成两个最大团$(x_1,x_3,x_4)和(x_2,x_3,x_4)$，所以：
  $P(Y)=\frac{1}{Z(x)}{\prod }_{c=1}^2{\psi }_c(c)=\frac{1}{Z(x)}{\psi }_1(x_1,x_3,x_4)\cdot {\psi }_2(x_1,x_3,x_4)$
  其中$Z(x)={\sum }_Y{\prod }_c{\psi }_c(c)$是归一化因子，这里可以参考softmax公式的分母。
  

• ${\psi }_c(c)$的定义
  ${\psi }_c(c)$是一个最大团$C$上随机变量们的联合概率，一般取指数函数:
  ${\psi }_c(Y_c)=e^{-E(Y_c)}=e^{{\sum }_k{\lambda }_k{f}_k(c,y,x)}$，先不管${\lambda }_k{f}_k(c,y,x)$是个什么鬼，把这一坨带入到上面的计算$P(Y)$的公式中：
  $P(Y)=\frac{1}{Z(x)}{\prod }_c{e}^{{\sum }_k{\lambda }_k{f}_k(c,y,x)}=\frac{1}{Z(x)}{e}^{{\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)}$
  现在是不是已经得到的crf的计算公式，到底要如何计算后面再说，先看看这个式子是怎么来的。首先，为什么长这个样子？因为弄这个东东出来的目的就是在给定序列$X$的情况下判定序列$Y$的，奔着$P(Y|X)$去的，判别式模型！其次，为什么在最后的公式中连乘符号没了？因为${\psi }_c(c)$这东东被定义成了指数函数，所以连乘变成了求和！

• 如何最大化$P(Y)$
  继续不管刚才那一坨怎么算，先从整体上把流程搞定再说细节。
  根据概率论课上老师教的，我们可以使用最大似然估计来计算分布的参数，即我们的目标就是最大化$logP(Y)$
  $logP(Y)=log\frac{1}{Z(x)}{e}^{{\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)}={\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)-logZ(x)$
  最大化$logP(Y)$等价于最小化$-logP(Y)$，所以目标就变成了最小化$-logP(Y)$
  $-logP(Y)=logZ(x)-{\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)$
  对应到代码实现中，关注neg_log_likelihood()函数的最后一行

def neg_log_likelihood(self, sentence, tags):
    feats = self._get_lstm_features(sentence)
    forward_score = self._forward_alg(feats)
    gold_score = self._score_sentence(feats, tags)
    return forward_score - gold_score

forward_score 就是我们的$logZ(x)$, gold_score是后面的那一坨。

• 解决细节
  上面一直都在把${\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)$当成一坨不去纠结他，但还是到了不得不面对的时候（终是庄周梦了蝶，你是恩赐也是劫）。
  先来看一下crf的长相(开始疯狂盗图)
  还记得上面提到的无向图的概率计算吗？需要分解成若干最大团然后连乘，OK！辣么把上面的图分解成若干最大团即可。怎么分？因为模型建立的初衷就是要考虑到$i_{k-1}$对$i_k$的影响和$X$对观测序列的影响，所以我们将图分解成若干个$(i_{k-1},i_k,X)$，其中$i_k$表示观测变量的状态值，比如在BIO标注中状态取值范围是{B,I,O,START,STOP}，则k最大取5，$i_k$有5个状态值可取。
  
  只关注其中的某一个团$C_i$，将${\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)$看成一个打分函数，表示在给定序列$X$情况下，表现出($i_{k-1},i_k$)的非归一化概率，这个概率与两个东东有关，一个是在序列$X$情况下由$i_{k-1}转移到i_k$的概率(在线性CRF中，假设观测变量只受临近结点的影响)，一个是给定序列$X$情况下出现$i_k$的概率，设：
  $g(i_{k-1},i_k;X)$表示在序列$X$情况下由$i_{k-1}转移到i_k$的概率；
  $h(i_k;X)$表示给定序列$X$情况下出现$i_k$的概率
  我们使用LSTM或者CNN来建模$X$对应$i_k$的映射，所以使用lstm的输出来代替$h(i_k;X)$；考虑到深度学习模型已经能比较充分捕捉各个$i_k$ 与X 的联系，所以假设$i_{k-1}转移到i_k$的概率与X无关，所以$g(i_{k-1},i_k;X)=g(i_{k-1},i_k)$这个转移概率是我们要学习的参数。于是就把${\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x)$写成了${\sum }_c{\sum }_k(h(i_k;X)+g(i_{k-1},i_k))$
  再盗一张图来说明计算过程
  
  先看一下上面两张图的关系，图中表示每一个$i_k$分别有4个状态可以取，对应到代码中是5个状态。
  

将图对应到公式中，k = 4对于每一步$t$都需要知道$h_k^{t+1}(i_k;X)$
而$Z_i^t$表示在当前时刻 t 以状态(标签) $y_1,\dots ,y_k$ 为终点的所有路径的得分指数和，即前向算法中的前向变量。我们来关注一下$Z_i^{t+1}$是怎么来的，$Z_1^{t+1}$是图中(在时刻t中所有红色的连线)$\times$(在t+1时刻状态为1的值)
$Z_1^{t+1}=Z_1^t\cdot G_{11}\cdot H_{t+1}(1|X)+Z_1^t\cdot G_{21}\cdot H_{t+1}(1|X)+Z_1^t\cdot G_{31}\cdot H_{t+1}(1|X)+Z_1^t\cdot G_{41}\cdot H_{t+1}(1|X)$
$Z_2^{t+1}=Z_2^t\cdot G_{12}\cdot H_{t+1}(2|X)+Z_2^t\cdot G_{22}\cdot H_{t+1}(2|X)+Z_2^t\cdot G_{32}\cdot H_{t+1}(2|X)+Z_2^t\cdot G_{42}\cdot H_{t+1}(2|X)$
…
$Z_i^{t+1}=Z_i^t\cdot G_{1i}\cdot H_{t+1}(i|X)+Z_i^t\cdot G_{2i}\cdot H_{t+1}(i|X)+Z_i^t\cdot G_{3i}\cdot H_{t+1}(i|X)+Z_i^t\cdot G_{4i}\cdot H_{t+1}(i|X)$
其中 G 是对 $g(y_i,y_j)$ 各个元素取指数后的矩阵
$G_{ij}=e^{g(y_i,y_j)}$
同理，$H_{t+1}(y_k|X)=e^{h_{t+1}((y_k|X)}$
对应到代码中

def _forward_alg(self, feats):
    # Do the forward algorithm to compute the partition function
    init_alphas = torch.full((1, self.tagset_size), -10000.)
    # START_TAG has all of the score.
    init_alphas[0][self.tag_to_ix[START_TAG]] = 0.

    # Wrap in a variable so that we will get automatic backprop
    forward_var = init_alphas

    # Iterate through the sentence
    for feat in feats:
        alphas_t = []  # The forward tensors at this timestep
        for next_tag in range(self.tagset_size):
            # 状态特征函数的得分
            emit_score = feat[next_tag].view(1, -1).expand(1, self.tagset_size)

            # 状态转移函数的得分
            trans_score = self.transitions[next_tag].view(1, -1)

            # 从上一个单词的每个状态转移到next_tag状态的得分
            # 所以next_tag_var是一个大小为tag_size的数组
            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.tag_to_ix[STOP_TAG]]
    alpha = log_sum_exp(terminal_var)
    return alpha

解释一下：

1. 在上述的代码中，所有计算都在$log$空间下进行，所以公式中的$\times$都变成了$+$；
2. 示例中的状态总共5个，分别是[B,I,O,START,STOP]，所以self.transitions是一个(5,5)的矩阵；
3. feats是BiLstm的输出，形状(句子数量，单词数量，5)，所以feats.shape()[1]就是步长，即上图中t的取值，比如一句话有11个单词，那么$t\in (1,2,...11)$；
4. emit_score 就是我们公式中的H()函数的输出，代码中每次先expand了一次，对应着公式$Z_i^{t+1}=Z_i^t\cdot G_{11}\cdot H_{t+1}(i|X)+Z_i^t\cdot G_{21}\cdot H_{t+1}(i|X)+Z_i^t\cdot G_{31}\cdot H_{t+1}(i|X)+Z_i^t\cdot G_{41}\cdot H_{t+1}(i|X)$中的$H_{t+1}(i|X)$；
5. trans_score 就是我们的状态转移函数G()，代码中每次取一行进行计算
   trans_score = self.transitions[next_tag].view(1, -1)，即公式中的$G_{1i},G_{2i},G_{3i},G_{4i}$；
6. 代码中的next_tag_var = forward_var + trans_score + emit_score就是公式中的$Z_i^t$了，我们的前向变量；
7. 求出所有的$Z_i^t$后使用log_sum_exp()来计算我们所需要的logZ(x)；
8. 如何计算$log{\sum }_{i=1}^k{e}^{a_i}$
   $log{\sum }_{i=1}^k{e}^{a_i}=A-log{\sum }_{i=1}^k{e}^{a_i-A}$ 其中$A=max(a_1,a_2,...,a_n)$
   所以log_sum_exp()长这样：

def log_sum_exp(vec):
    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)))

• viterbi解码算法
  官方给出的代码中实现了很标准的viterbi算法，只要记住
  ${\delta }_{t+1}=ma{x}_{1⩽j⩽k}({\delta }_t+{\sum }_c{\sum }_k{\lambda }_k{f}_k(c,y,x))$具体理论请参加李航大大的统计学习，就不再搬运了。

def _viterbi_decode(self, feats):
    backpointers = []

    # Initialize the viterbi variables in log space
    init_vvars = torch.full((1, self.tagset_size), -10000.)
    init_vvars[0][self.tag_to_ix[START_TAG]] = 0

    # forward_var at step i holds the viterbi variables for step i-1
    forward_var = init_vvars
    for feat in feats:
        bptrs_t = []  # holds the backpointers 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.tag_to_ix[STOP_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.tag_to_ix[START_TAG]  # Sanity check
    best_path.reverse()
    return path_score, best_path

参考文档

[1] https://www.jiqizhixin.com/articles/2018-05-23-3
[2] https://zhuanlan.zhihu.com/p/71190655
[3] https://zhuanlan.zhihu.com/p/33397147
[4] https://pytorch.org/tutorials/beginner/nlp/advanced_tutorial.html
[5] https://blog.csdn.net/zycxnanwang/article/details/90385259