Easy_Bert_WordSeg

利用Bert_CRF进行中文分词

bert_crf模型还可以用于实体识别、词性标注等。

预训练的bert中文模型：

下载地址链接：https://storage.googleapis.com/bert_models/2018_11_03/chinese_L-12_H-768_A-12.zip

checkpoints 里面保存的参数太大了,一个有1G，上传不了. 有需要的自己训练。重要的是了解模型搭建的过程。

备注

模型训练了10个epoch，我就停掉了。原本的打算是每个epoch结束，返回一次测试集精度，精度提升才保存模型(跟之前的bert文本分类做法一样), 但精度测试这里有点问题，没找到好的方法，所以就直接每5个epoch保存一次模型。10个epoch后，loss从40 ---> 1左右。继续迭代下去能到0.1左右。

模型过程

数据集

数据集来自nlpcc2016, 数量有点少 20000 条左右。

数据处理

第一步： 将句子转化为 'B M E S' 序列

B：表示词的开始

M：表示词的中间

E：表示词的结束

S：表示单字成词

例如：中文模型 ---> BMME

#将句子转换为BMES序列
def get_str(sentence):
   output_str = []
   sentence = re.sub('  ', ' ', sentence) #发现有些句子里面，有两格空格在一起
   list = sentence.split(' ')
   for i in range(len(list)):
       if len(list[i]) == 1:
           output_str.append('S')
       elif len(list[i]) == 2:
           output_str.append('B')
           output_str.append('E')
       else:
           M_num = len(list[i]) - 2
           output_str.append('B')
           output_str.extend('M'* M_num)
           output_str.append('E')
   return output_str

第二步：处理成bert模型所需数据

tokenizer = tokenization.FullTokenizer(vocab_file=pm.vocab_filename, do_lower_case=False) 加载预训练bert模型的中文词典
text = tokenizer.tokenize(eachline)  将句子转换成 字列表，如：输入“你好”，返回['你','好']
bert需要在字列表首位添加 "[CLS]"，尾部添加"[SEP]"字符
text.insert(0, "[CLS]")
text.append("[SEP]")
返回数据为：['CLS','你','好','SEP']
然后将列表字转换成数字，还是利用bert中文字典，
text2id = tokenizer.convert_tokens_to_ids(text) 将字列表 变成 数字列表

segemnt表示输入的句子是段落几，第一段落用0表示，第二段落用1表示，...。bert能够接受的中文句子长度为512，大于这个长度可以分段输入。

mask矩阵，句子原长度部分，权重值为1，padding得来的部分，权重值为0

接下来，将label转换成数字，state_list = {'B': 1, 'M': 2, 'E': 3, 'S': 4, '[CLS]': 5, '[SEP]': 6}
_label = [state_list[key] for key in label_]

padding部分，不足设定长度的句子，补0
        while len(text2id) < pm.seq_length:
            text2id.append(0)
            mask_.append(0)
            segment.append(0)
            _label.append(0)
        assert len(text2id) == pm.seq_length
        assert len(mask_) == pm.seq_length
        assert len(segment) == pm.seq_length
        assert len(_label) == pm.seq_length

此外，crf在计算最大似然数时sequence_lengths=real_sequlength，这里输入的是句子的真实长度(也就是减去padding部分的长度)。
def sequence(x_batch):
    seq_len = []
    for line in x_batch:
        length = np.sum(np.sign(line))
        seq_len.append(length)
    return seq_len
 利用这个程序来计算。

最后，得到的input_id, input_segment, mask, seq_len, label为模型的输入。具体程序在data_process.py里。

构建模型

bert模型：

with tf.variable_scope('bert'):
   bert_embedding = modeling.BertModel(config=bert_config,
                                       is_training=True,
                                       input_ids=input_x,
                                       input_mask=mask,
                                       token_type_ids=input_segment,
                                       use_one_hot_embeddings=False)

   embedding_inputs = bert_embedding.get_sequence_output()
is_training=True表示进行finetune,  use_one_hot_embeddings=False表示不使用TPU。
bert_embedding.get_sequence_output()输出数据形式[batch_size,seq_length,hidden_dim],hidden_dim=768

crf模型：

#bert预训练模型输出形状[batch_size, max_seq_length, hidden_dim]
#进行处理，形状改为[batch_size*max_seq_length, hidden_dim]
#进行全连接，输出结果形状为[batch_size*max_seq_length, pm.num_tags]
#重新转为三维形状，进行crf层
with tf.variable_scope('crf'):
    outputs = embedding_inputs
    hidden_size = outputs.shape[-1].value
    output = tf.reshape(outputs, [-1, hidden_size])
    output = tf.layers.dense(output, pm.num_tags)
    output = tf.contrib.layers.dropout(output, pm.keep_prob)
    logits = tf.reshape(output, [-1, pm.seq_length, pm.num_tags])
    log_likelihood, transition_params = crf_log_likelihood(inputs=logits, tag_indices=input_y,
                                                           sequence_lengths=real_sequlength)

loss损失函数:

with tf.variable_scope('loss'):
    loss = tf.reduce_mean(-log_likelihood) #最大似然取负，使用梯度下降

optimizer优化器:

with tf.variable_scope('optimizer'):
    num_train_steps = int((length_text) / pm.batch_size * pm.num_epochs)
    num_warmup_steps = int(num_train_steps * 0.1)  # 总的迭代次数 * 0.1 ,这里的0.1 是官方给出的，我直接写过来了
    train_op = optimization.create_optimizer(loss, pm.lr, num_train_steps, num_warmup_steps, False)
 官方提供的 optimization 主要是学习速率可以动态调整，如下面简图，学习速率由小到大，峰值就是设置的lr,然后在慢慢变小，
 整个学习速率，呈现三角形

                 -
               -      -
             -          -
           -                 -

获取预训练bert模型中所有的训练参数：

# 获取模型中所有的训练参数。
tvars = tf.trainable_variables()
# 加载BERT模型
(assignment_map, initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(tvars, pm.init_checkpoint)

tf.train.init_from_checkpoint(pm.init_checkpoint, assignment_map)

tf.logging.info("**** Trainable Variables ****")
# 打印加载模型的参数
for var in tvars:
    init_string = ""
    if var.name in initialized_variable_names:
        init_string = ", *INIT_FROM_CKPT*"
    tf.logging.info("  name = %s, shape = %s%s", var.name, var.shape,
                    init_string)
session = tf.Session()
session.run(tf.global_variables_initializer())

训练模型

for epoch in range(pm.num_epochs):
        print('Epoch:', epoch + 1)
        num_batchs = int((len(label) - 1) / pm.batch_size) + 1
        batch_train = batch_iter(input_id, input_segment_, mask_, label, pm.batch_size)
        for x_id, x_segment, x_mask, y_label in batch_train:
            n += 1
            sequ_length = sequence(x_id)
            feed_dict = feed_data(x_id, x_mask, x_segment, y_label, sequ_length, pm.keep_prob)
            _,  train_summary, train_loss = session.run([train_op, merged_summary, loss], feed_dict=feed_dict)

            if n % 100 == 0:
                print('步骤:', n, '损失值:', train_loss)
        # P = evaluate(session, test_id, test_segment, test_mask, test_label)
        # print('测试集准确率:', P)
        # if P > best:
        #     best = P
        if (epoch+1) % 5 == 0:
            print("Saving model...")
            saver.save(session, save_path, global_step=((epoch + 1) * num_batchs))

batch_size为12，每当步骤为100的倍数，输出此时的loss,当epoch数为5的倍数时，保存一次模型。

在备注里面说了， 测试精度过程写的不好，但我没删，有需要的可以加以改进。这部分是训练模型中的 evaluate函数。

验证模型

验证模型的分词效果，主要是使用viterbi进行解码。至于这里的feed_dict里面的参数，为什么要加一个'[]'，如：[text2id]。
因为text2id是一个句子，列表为1维tensor,我需要将其变成2维tensor。
    logits_, transition_params_ = sess.run([logits, transition_params], feed_dict={input_x: [text2id],
                                                                                   input_segment: [segment],
                                                                                   mask: [mask_],
                                                                                   real_sequlength: [seqlength],
                                                                                   keep_pro: 1.0})

    # logit 每个子句的输出值，length子句的真实长度，logit[:length]的真实输出值
    # 调用维特比算法求最优标注序列
    label = []
    for logit, length in zip(logits_, [seqlength]):
        viterbi_seq, _ = viterbi_decode(logit[:length], transition_params_)
        label = [key for key in viterbi_seq]

训练10个epoch,分词效果如图。