CRF的三个核心函数

https://www.jianshu.com/p/bddf0641970c

CRF的实现-tensorflow版本
不分享的知识毫无意义
0.076
2020.03.14 17:33:26
字数 1,039阅读 588
0.前言

CRF的原理已经够难理解了，需要解决的问题主要包括三大块：

概率计算问题，前向—后向算法，是一个递推公式，这个和hmm是一样的。
学习问题，这是判别式模型必须要有的东西，得训练参数，常用的方法是改进的迭代尺度法，拟牛顿法。
预测问题，维特比算法，这是个动态规划方法，hmm和crf都会用到。这个好像废话，目的都是为了预测，当然要用。
数学公式一大堆，什么向量形式，矩阵形式，着实难以理解，但是关于事先就很简单了，哈哈哈。下面分别基于tensorflow、keras、pytorch来实现CRF。

1.tensorflow实现

tensorflow1.0可真难用啊，吐槽一下，还是2.0好用。举个小例子，你定义一个op操作以后，即使是简单的x1+x2，要想看输出，还得print(sess.run())，2.0就不用了，大家赶紧上手2.0。不过这里还是基于tensorflow1.0实现的。
tensorflow实现crf就三个函数，crf_log_likelihood、viterbi_decode、crf_decode，他们都在tf.contrib.crf这个API里，搞懂这三个函数，不管事BiLSTM+CRF还是BERT+BiLSTM+CRF你都游刃有余了。

tf.contrib.crf.crf_log_likelihood
crf_log_likelihood(inputs,tag_indices,sequence_lengths,transition_params=None)
通俗理解，这是CRF的训练函数。
首先来看输入：
（1）inputs，维度为[batch_size, max_seq_len, num_tags]，一般是LSTM的输出，要转换成这个要求的维度，再到CRF里边训练。
batch_size是批次训练样本量，好理解，不解释。
maxseq_len是输入文本的长度，相当于LSTM里的input_dim，就是输入几个单词。
num_tags是可供选择的单词个数，比如你觉得这个位置有5个可能的单词，那这个就是5。
（2）tag_indices，维度为[batch_size, max_seq_len]。
具体的和inputs一样，只不过这个是真实的标签，也就是相应位置对应的真实y值。
（3）sequence_lengths，维度为 [batch_size]。
表示的是每一个序列的长度，是一维的，相当于max_sql_len，可以用np.full这个函数实现。
（4）transition_params，维度为[num_tags, num_tags]，是转移矩阵，要是事先没有就训练一个。
然后来看输出：
（1）log_likelihood，标量，还记得吧，CRF训练参数用的是极大似然估计，这个值取负数就是交叉熵损失。
（2）transition_params，维度为[num_tags, num_tags]，转移矩阵，这个是我们预测要用到的。
tf.contrib.crf.viterbi_decode
viterbi_decode(score,transition_params)
这个函数返回最好序列的标签，用的场景不是特别多。
输入：
（1）score,维度为[seq_len, num_tags]，参数的意思就不解释了，具体看上边的说法，这就是一个得分。
（2）transition_params，维度为[num_tags, num_tags]，上边训练输出的转移矩阵。
输出：
（1）viterbi，维度[seq_len]，保留了每一步对应得分值最高的索引。
（2）viterbi_score，维度为[sel_len]，这个是维特比的具体得分。
tf.contrib.crf.viterbi_decode
crf_decode(potentials,transition_params,sequence_length)
这个函数和上边那个差不多，但是很常用。
输入：
（1）potentials，维度为[batch_size, max_seq_len, num_tags]，这个是满足条件的一个输入，可以使输入和一个权重矩阵乘后的结果。
（2）transition_params，转义矩阵不多说。
（3）sequence_length，和上边一样，输入长度构成的一维矩阵。
输出：
（1）decode_tags，维度为[batch_size, max_seq_len] ，是一个最好序列的标记。
（2）best_score，维度为[batch_size]，每个序列的最好得分。
来看一个小例子，这个例子是一个随机的数字输入，对应一个只含0，1两个状态的目标矩阵，然后根据输入预测输出。代码如下：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
Timestep = 15#输入的总长度，可以理解为15个rnn cell
Batchsize = 1#一次就输入一个
Inputsize = 1
LR = 0.5
num_tags = 2
#定义batch输出
def get_batch():
    xs = np.array([[2, 3, 4, 5, 5, 5, 1, 5, 3, 2, 5, 5, 5, 3, 5]])
    res = np.array([[0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1]])
    return [xs[:, :, np.newaxis], res]
# xs, res = get_batch()
# print(xs)
# xs变成三维的 res还是二维的
class crf:
    def __init__(self, time_steps, input_size, num_tags, batch_size):
        self.time_steps = time_steps
        self.input_size = input_size
        self.num_tags = num_tags
        self.batch_size = batch_size
        self.xs = tf.placeholder(tf.float32, [None, self.time_steps, self.input_size], name='xs')
        self.res = tf.placeholder(tf.int32, [self.batch_size, self.time_steps], name='res')#为什么和xs的定义模式不一样
        weights = tf.get_variable('weights', [self.input_size, self.num_tags])
        matricized_xs = tf.reshape(self.xs, [-1, self.input_size])
        matricized_unary_scores = tf.matmul(matricized_xs, weights)
        unary_scores = tf.reshape(matricized_unary_scores, [self.batch_size, self.time_steps, self.num_tags])
        sequence_len = np.full(self.batch_size, self.time_steps, dtype=np.int32)
        log_likelihood, transition_params = tf.contrib.crf.crf_log_likelihood(unary_scores, self.res, sequence_len)
        self.pred, viterbiscore = tf.contrib.crf.crf_decode(unary_scores, transition_params, sequence_len)
        self.loss = tf.reduce_mean(-log_likelihood)
        self.train_op = tf.train.AdamOptimizer(LR).minimize(self.loss)


if __name__ == '__main__':
    model = crf(Timestep, Inputsize, num_tags, Batchsize)
    sess = tf.Session()
    sess.run(tf.initialize_all_variables())
    plt.ion()#动态曲线
    plt.show()
    for i in range(150):
        xs, res = get_batch()
        feed_dict = {model.xs: xs,
                     model.res: res}
        _, cost, pred = sess.run([model.train_op, model.loss, model.pred],
                                 feed_dict=feed_dict)#只有placeholder才可以feed
        x = xs.reshape(-1, 1)
        r = res.reshape(-1, 1)
        p = pred.reshape(-1, 1)
        x = range(len(x))
        plt.clf()
        plt.plot(x, r, 'r', x, p, 'g')
        plt.ylim(-1.2, 1.2)
        plt.draw()
        plt.pause(0.3)
        if i % 20 == 0:
            print('cost:', round(cost, 4))