NLP中BERT在文本二分类中的应用

最近参加了一次kaggle竞赛Jigsaw Unintended Bias in Toxicity Classification，经过一个多月的努力探索，从5月20日左右到6月26日提交最终的两个kernel，在public dataset上最终排名为4%(115/3167)，说实话以前也并没有怎么接触过NLP方面的东西，对深度学习的理解也不是特别深刻。
BERT是目前非常火的NLP模型，采用两段式的训练方式，分为pretrain和fine-tune两部分，pretrain部分由谷歌在TPU集群上训练完成，并给出部分模型供免费下载使用。其中包括’cased_l-24_h-1024_a-16’, ‘chinese_l-12_h-768_a-12’, ‘uncased_l-12_h-768_a-12’, ‘uncased_l-24_h-1024_a-16’, ‘multi_cased_l-12_h-768_a-12’, ‘cased_l-12_h-768_a-12’

github上的下载地址为
https://github.com/google-research/bert
在本次比赛中主要采用的是BERT-Base,uncased的这个model，训练全数据180万左右的样本，样本长度设为220，在四卡Titan的GPU卡上训练的时间接近6小时，BERT-Large,uncased的训练时间大概是33小时左右。uncased和cased的区别在于uncased将全部样本变为小写，而cased则要区分大小写，将cased和uncased的模型训练结果进行融合也会有一定程度的提升。
比赛的主要代码是在一个以色列大佬的kernrl上进行修改，比赛结束时已经被fork了将近1595，代码地址
https://www.kaggle.com/yuval6967/toxic-bert-plain-vanila，非常感谢这位无私的大佬

代码详解

将样本文本转为成bert-format

def convert_lines(example, max_seq_length,tokenizer):
    max_seq_length -=2
    all_tokens = []
    longer = 0
    for text in tqdm_notebook(example):
        tokens_a = tokenizer.tokenize(text)
        if len(tokens_a)>max_seq_length:
            tokens_a = tokens_a[:max_seq_length]
            longer += 1
        one_token = tokenizer.convert_tokens_to_ids(["[CLS]"]+tokens_a+["[SEP]"])+[0] * (max_seq_length - len(tokens_a))
        all_tokens.append(one_token)
    print(longer)
    return np.array(all_tokens)

应用BERT模型进行词嵌入，转换成sequences

bert_config = BertConfig('../input/bert-pretrained-models/uncased_l-12_h-768_a-12/uncased_L-12_H-768_A-12/'+'bert_config.json')
tokenizer = BertTokenizer.from_pretrained(BERT_MODEL_PATH, cache_dir=None,do_lower_case=True)
train_df = pd.read_csv(os.path.join(Data_dir,"train.csv")).sample(num_to_load+valid_size,random_state=SEED)
train_df['comment_text'] = train_df['comment_text'].astype(str) 
sequences = convert_lines(train_df["comment_text"].fillna("DUMMY_VALUE"),MAX_SEQUENCE_LENGTH,tokenizer)
#此处可以对其进行保存，下次可以直接调用npy文件
#np.save('sequences.npy',sequences)
#sequences = np.load('../wql/wql_base_sequences.npy')

通过uncased_L-12_H-768_A-12文件下的bert_model.ckpt和bert_config.json文件，在working目录下生成pytorch_model.bin文件，并copy其中的bert_config.json到working目录下

BERT_MODEL_PATH = '../input/bert-pretrained-models/uncased_l-12_h-768_a-12/uncased_L-12_H-768_A-12/'
convert_tf_checkpoint_to_pytorch.convert_tf_checkpoint_to_pytorch(
    BERT_MODEL_PATH + 'bert_model.ckpt',
BERT_MODEL_PATH + 'bert_config.json',
WORK_DIR + 'pytorch_model.bin')
shutil.copyfile(BERT_MODEL_PATH + 'bert_config.json', WORK_DIR + 'bert_config.json')

实例化模型

train_dataset = torch.utils.data.TensorDataset(torch.tensor(X,dtype=torch.long), torch.tensor(y,dtype=torch.float))
#实例化模型，确保working目录下有bert_config.json文件和pytorch_model.bin文件，
model = BertForSequenceClassification.from_pretrained('./working/',cache_dir=None,num_labels=1)
#四卡并行计算的代码
devices = [0,1,2,3]
if len(devices) > 1:
    print('use multi gpus')
    model = nn.DataParallel(model, device_ids=devices)
    model = model.cuda(devices[0])
#定义权重衰减的参数
no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
    {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},
    {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
    ]
model=model.train()

设置bert训练的参数

lr=2e-5
#若batch_size大可能导致cuda memory out的问题，可以通过减低batchsize来解决，在训练large时，batchsize设过4
batch_size = 100
#用于参数更新的加速，设为2，参数更新的次数为1的1/2
accumulation_steps=2
save_steps = 1000
checkpoint = None
# 全数据训练的epoch次数
EPOCHS = 1
num_train_optimization_steps = int(EPOCHS*len(train) / batch_size / accumulation_steps)
optimizer = BertAdam(optimizer_grouped_parameters,
                     lr=lr,  #在epoch2时可适当降低lr，例如取其1/2
                     warmup=0.05,   #当lr下降的时候，也可以降低warmup，例如epoch2时设为0
                     t_total=num_train_optimization_steps)

开始进行一个epoch的全样本数据训练，batch_size为100

tq = tqdm_notebook(range(EPOCHS))
for epoch in tq:
    #将avg_loss和avg_accuracy写入txt文件
    file_name = 'loss_log_' + 'epoch' + str(epoch) + '.txt'
    file = open(file_name, 'w', encoding='utf-8')
    
    train_loader = torch.utils.data.DataLoader(train, batch_size=batch_size, shuffle=True)
    avg_loss = 0.
    avg_accuracy = 0.
    optimizer.zero_grad()   
    for (x_batch, y_batch) in tqdm(train_loader):
        y_pred = model(x_batch.cuda(), attention_mask=(x_batch>0).cuda(), labels=None)
        loss = nn.随意一个loss-function()(y_pred, y_batch.cuda())
        loss.backward()
        optimizer.step()  # Now we can do an optimizer step
        optimizer.zero_grad()
        avg_loss += loss.item() / len(train_loader)
        avg_accuracy += torch.mean(((torch.sigmoid(y_pred[:,0])>0.5) == (y_batch[:,0]>0.5).cuda()).to(torch.float) ).item()/len(train_loader)
        i += 1
        
        file.write('batch' + str(i) + '\t' + 'avg_loss' + '=' + str(avg_loss) + '\t' + 'avg_accuracy' + '=' + str(avg_accuracy) + '\n')
    file.close()
    
    file_path = output_model_file + str(epoch) +'.bin'
    #保存bert model用于迁移学习或测试
    torch.save(model.state_dict(), file_path)
    print(f'loss:{avg_loss} accuracy:{avg_accuracy}')

应用过程中的一点理解

就我目前对bert的理解和在比赛中调参的过程来浅谈一点经验，大佬贴出了bert模型的模板，几乎所有选手都采用这位大佬的模型作为原本进行改写，有几个重要点可以进行改写来提高预测的准确率

loss-function

首先是loss-function，这决定了这次比赛的成败，如果没法写出一个适合比赛的lossfunction，那么比赛最终成绩也就是可以fork到的最高分。虽然大佬在bert fine-tune中只给出了F.binary_cross_entropy_with_logits，但是在其他LSTM的kernel上却给出了下面这样比较优秀的loss

def custom_loss(data, targets):
     bce_loss_1 = nn.BCEWithLogitsLoss(weight=targets[:,1:2])(data[:,:1],targets[:,:1])
     bce_loss_2 = nn.BCEWithLogitsLoss()(data[:,2:],targets[:,2:])
     return (bce_loss_1 * loss_weight) + bce_loss_2

可以通过一定的补充，应用到bert模型中去，仅仅是这样一步就使得bert的预测准确率提高了很多

epoch

在对全样本数据进行fine-tune的过程中发现，训练到第三个epoch的时候，bert模型就发生了过拟合，通过小样本数据多次进行lr的调整之后也得到同样的结果，因此epoch的数量设置为2，比赛结束后一些高分单个bert的epoch数量也确实是2。

参数调整

在我看来fine-tune过程中可以调节的参数应该有以下几个，lr、warmup、dropout、accumulation_steps、batch_size、weight_decay，MAX_SEQUENCE_LENGTH

hidden_dropout_prob: The dropout probabilitiy for all fully connected layers in the embeddings, encoder, and pooler.
attention_probs_dropout_prob: The dropout ratio for the attention probabilities.

accumulation_steps减小从实践效果来说可以略微提升训练效果。
weight_decay 调整之后并没有收到准确率提升的效果
lr的话，第一个epoch为2e-5,第二个epoch为1e-5是相对较好的lr参数
batch_size对于结果影响并不大，越大的batchsize计算速度越快，但是对于gpu的显存要求更高
MAX_SEQUENCE_LENGTH 规定了sequence的长度，长度越长对显存要求也越高
warmup 一个高分的bert模型中,epoch0 lr为2e-5,warmup为0.05，epoch1 lr为1e-5,warmup为0，对结果有一定的提升
给出一高分的bert模型地址 https://www.kaggle.com/hanyaopeng/single-bert-base-with-0-94376
其实我对bert理解也只停留在模型的应用上，如有了解的大佬看到觉得不对的地方，希望指出错误。