BiLSTM-CRF计算细节

1、计算所有路径得分的对数指数和

  def _forward_alg(self, feats):
        init_alphas = torch.full((1, self.tagset_size), -10000.).cuda()
        init_alphas[0][self.tag_to_ix[START_TAG]] = 0.
        #注释1
        forward_var = init_alphas
        #注释2
        for feat in feats:  
        #注释3
            alphas_t = [] 
            for next_tag in range(self.tagset_size):
                #注释4
                emit_score = feat[next_tag].view(1, -1).expand(1, self.tagset_size) 
                #注释5  
                trans_score = self.transitions[next_tag].view(1, -1)
                #注释6
                next_tag_var = forward_var + trans_score + emit_score
                #注释7
                alphas_t.append(log_sum_exp(next_tag_var).view(1))
                #注释8
            forward_var = torch.cat(alphas_t).view(1, -1)
            #注释9
        terminal_var = forward_var + self.transitions[self.tag_to_ix[STOP_TAG]]
        alpha = log_sum_exp(terminal_var)
        #注释10
        return alpha

• 注释1：$\_forward\_alg$用来计算所有路径得分的对数指数和。$init\_alpahs=[p_{1,0},p_{2,0},...,p_{m,0}]$,即在时刻0到各状态的路径得分。由于时刻0不可能到其他状态，所以初始化为-10000，在时刻0的状态就是$start$，所以将$p_{start\_ix,0}$初始化为0.
• 注释2：我们需要对每一个时刻$t$都计算一个$forward\_var=[p_{1,t},p_{2,t},...,p_{m,t}]$以存放在时刻$t$到各状态的路径得分的对数指数和。在时刻0即令$forward\_var=[p_{1,0},p_{2,0},...,p_{m,0}]$。
• 注释3：$feat$为时刻$t$各状态的状态分数（我觉得不能称之为发射分数，因为CRF为无向图），其具体表达式为$[B_{t,1},B_{t,2},...,B_{t,m}]$。第一个$for$循环在时间维度进行。
• 注释4：进入第二个$for$循环，此时是对各状态进行遍历。以下注释用$i$代替$next\_tag$。
• 注释5：$emit\_score=[B_{t,i},B_{t,i},...,B_{t,i}]$，即时刻$t$为状态$i$的得分的广播。
• 注释6：$tran{s}_{s}core=[A_{i,1},A_{i,2},...,A_{i,m}]$，即各状态转移到状态$i$的得分。
• 注释7：$forward\_var$为上一时刻$t-1$到各状态的得分的对数指数和，即$forward\_var=[p_{1,t-1},p_{2,t-1},...,p_{m,t-1}]$。
  $$\begin{array}{rl}& [p_{1,t-1},p_{2,t-1},...,p_{m,t-1}]+\\ & [B_{t,i},B_{t,i},...,B_{t,i}]+\\ & [A_{i,1},A_{i,2},...,A_{i,m}]+\\ & =[Q_1,Q_2,...,Q_m]\end{array}$$
• 注释8：计算$p_{i,t}=log(e^{Q_1}+e^{Q_2}+...+e^{Q_m})$，并将其加入列表$alphas\_t$中。
• 注释9：当各状态遍历结束后，我们就得到列表$alphas\_t=[p_{1,t},p_{2,t},...,p_{m,t}]$，将其转换为张量，并赋值给$forward\_var$，得到$forward\_var=[p_{1,t},p_{2,t},...,p_{m,t}]$以便继续重复上述步骤去计算$[p_{1,t+1},p_{2,t+1},...,p_{m,t+1}]$。
• 注释10：完整的所有路径得分的对数指数和还应该加上各个状态转移到$stop$的得分，并取对数指数和。就得到完整的所有路径的得分的对数指数和，为$forward\_score=log(e^{p_1}+e^{p_2}+...+e^{p_{n^m}})$。

2、计算真实路径的得分

    def _score_sentence(self, feats, tags):
        # 注释1
        score = torch.zeros(1).cuda()
        tags=torch.cat([torch.tensor([self.tag_to_ix[START_TAG]],dtype=torch.long).cuda(), tags]) 
         # 注释2
        for i, feat in enumerate(feats):
            #注释3
            score = score + self.transitions[tags[i + 1], tags[i]] + feat[tags[i + 1]]
        score = score + self.transitions[self.tag_to_ix[STOP_TAG], tags[-1]]
        #注释4
        return score.cuda()

• 注释1：计算给定tag的分数，即一条路径的分数
• 注释2：将$start$加入$tags$，成为新的$tags$，因为原始的$tags$中并没有$start$，而在计算路径得分时，我们需要考虑由start转移到其他状态的分数
• 注释3：计算分数=转移分数+状态分数
• 注释4：这里的score为真实路径得分

3、关于CRF损失函数

    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  

  我们的目的是希望$$\frac{e^{p_{real\_path}}}{e^{p_1}+e^{p_2}+...+e^{p_{n^m}}}$$
尽可能大，取对数并取符号，即可得到损失函数
$$Loss=log(e^{p_1}+e^{p_2}+...+e^{p_{n^m}})-p_{real\_path}$$
所以$\_forward\_alg$函数计算的是所有路径的对数指数和，而$\_score\_sentence$函数计算的就是真实路径的得分。

4、Viterbi解码

    def _viterbi_decode(self, feats):
        backpointers = [] 
        #注释1
        init_vvars = torch.full((1, self.tagset_size), -10000.)
        init_vvars[0][self.tag_to_ix[START_TAG]] = 0
        forward_var = init_vvars
        #注释2
        for feat in feats:
            bptrs_t = []  
            viterbivars_t = []  
            for next_tag in range(self.tagset_size):
                next_tag_var = forward_var.cuda() + self.transitions[next_tag].cuda()
                best_tag_id = argmax(next_tag_var)
                #注释3
                bptrs_t.append(best_tag_id)
                viterbivars_t.append(next_tag_var[0][best_tag_id].view(1))
                #注释4
            forward_var = (torch.cat(viterbivars_t) + feat).view(1, -1)
            #注释5
            backpointers.append(bptrs_t) 
            #注释6
        terminal_var = forward_var + self.transitions[self.tag_to_ix[STOP_TAG]]  
        #注释7
        best_tag_id = argmax(terminal_var)
        path_score = terminal_var[0][best_tag_id]
        #注释8
        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)
        #注释9
        start = best_path.pop()  
        #最初的start被剔除
        assert start == self.tag_to_ix[START_TAG]  
        best_path.reverse()
        return path_score, best_path

• 注释1：$backpointers$其用来记录最优路径，其为二维列表，$[t][i]$元素为时刻$t$，状态$i$是由前一个时刻的哪一个状态转移而来会使得分数最大。
• 注释2：$forward\_var$其记录下当前时刻各个状态的最优分数，即$forward\_var=[{\delta }_{1,t},{\delta }_{2,t},...,{\delta }_{m,t}]$。${\delta }_{i,t}$表示在时刻$t$若为状态$i$的最优分数。
• 注释3：计算${\delta }_{i,t+1}$不需要加上发射概率，在这两个$for$循环下，代表时刻$t+1$的状态$i$，此时发射概率都相同。 $${\delta }_{i,t+1}=Max\{\begin{array}{rl}& {\delta }_{1,t}+A_{i,1}+B_{i,t+1}\\ & {\delta }_{2,t}+A_{i,2}+B_{i,t+1}\\ & ⋮\\ & {\delta }_{m,t}+A_{i,m}+B_{i,t+1}\end{array}$$
  即$[{\delta }_{1,t},{\delta }_{2,t},...,{\delta }_{m,t}]+[A_{i,1},A_{i,2},...,A_{i,m}]=next\_tag\_var$，然后使用$argmax$找出由前一时刻哪个状态转移而来分数最大，将前一时刻的该状态赋值给$best\_tag\_id$，即 $$best\_tag\_id=Max\{\begin{array}{rl}& {\delta }_{1,t}+A_{i,1}\\ & {\delta }_{2,t}+A_{i,2}\\ & ⋮\\ & {\delta }_{m,t}+A_{i,m}\end{array}$$
• **注释4：**将$best\_tag\_id$加入进$bptrs\_t$，其存放当前时刻$t+1$的各个状态分别由前一个时刻的哪个状态转移而来分数最优。$viterbivars\_t$则存放了当前时刻$t+1$的各个状态最优分数（其实不完整，需要分别加上当前时刻$t+1$各个状态的状态分数）
• **注释5：**之前没有加上 当前时刻$t+1$各个状态的状态分数，需要加上才是完整的最优分数。$$viterbivars\_t+[B_{1,t+1},B_{2,t+1},...,B_{m,t+1}]=[{\delta }_{1,t+1},{\delta }_{2,t+1},...,{\delta }_{m,t+1}]=forward\_var$$
• 注释6：$backpointers$其用来记录最优路径，其为二维列表，$[t][i]$元素为时刻$t$，状态$i$是由前一个时刻的哪一个状态转移而来会使得分数最大。
• 注释7： 最后需要加上该状态转移到stop的分数才完整，不用加上到stop的状态分数，该状态分数不存在，因为没有一个词属于状态stop。即$[{\delta }_{1,n},{\delta }_{2,n},...,{\delta }_{m,n}]+[A_{stop\_ix,1},A_{stop\_ix,2},...,A_{stop\_ix,m}]=terminal\_var$。
• 注释8：$best\_tag\_id$记录最后时刻哪一个状态到$stop$分数最优（大），$path\_score$记录下从$start$到$stop$的最优路径的得分。
• 注释9：从后往前找到最优路径，存放于$best\_path$。