NLP算法实战项目：使用 BERT 进行文本多分类

大多数研究人员将他们的研究论文提交给学术会议，因为这是更快地使研究结果可用的途径。寻找和选择合适的会议一直是一项具有挑战性的任务，特别是对于年轻的研究人员来说。基于先前会议论文集的数据，研究人员可以增加其论文被接受和发表的机会。

今天，我们将尝试使用 BERT 进行深度学习来解决这个文本分类问题。无论是想项目学习还是面试需要，这都一个很好的学习机会。

喜欢本文记得收藏、关注，点赞，完整代码与数据，可以文末技术群获取。

数据

该数据集包含2,507篇研究论文标题，并已手动分类为5个类别（即会议）

探索与预处理

import torch
from tqdm.notebook import tqdm

from transformers import BertTokenizer
from torch.utils.data import TensorDataset

from transformers import BertForSequenceClassification

df = pd.read_csv('data/title_conference.csv')
df.head()

df['Conference'].value_counts()

您可能已经注意到我们的类别不平衡，我们将在稍后解决这个问题。

对标签进行编码

possible_labels = df.Conference.unique()

label_dict = {}
for index, possible_label in enumerate(possible_labels):
    label_dict[possible_label] = index
label_dict

df['label'] = df.Conference.replace(label_dict)

训练和验证集划分

由于标签不平衡，我们以分层的方式划分数据集，使用这个作为类别标签。

在划分后，我们的标签分布将如下所示。

from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(df.index.values, 
                                                  df.label.values, 
                                                  test_size=0.15, 
                                                  random_state=42, 
                                                  stratify=df.label.values)

df['data_type'] = ['not_set']*df.shape[0]

df.loc[X_train, 'data_type'] = 'train'
df.loc[X_val, 'data_type'] = 'val'

df.groupby(['Conference', 'label', 'data_type']).count()

BertTokenizer 和数据编码

标记化是将原始文本拆分为标记的过程，这些标记是表示单词的数字数据。

我们构建一个基于WordPiece的BERT标记器。
实例化一个预训练的BERT模型配置来编码我们的数据。
为了将所有标题从文本转换为编码形式，我们使用一个名为batch_encode_plus的函数，并且我们将分别处理训练和验证数据。
上述函数中的第一个参数是标题文本。
add_special_tokens=True意味着序列将被编码为相对于它们的模型的特殊标记。
当将序列批处理在一起时，我们设置return_attention_mask=True，这样它将根据max_length属性定义的特定标记器返回注意力掩码。
我们还希望将所有标题填充到特定的最大长度。
实际上，我们不需要设置max_length=256，只是为了谨慎起见。
return_tensors=‘pt’ 用于返回PyTorch张量。
然后，我们需要将数据分成input_ids、attention_masks和labels。
最后，在获取编码数据集后，我们可以创建训练数据和验证数据。

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', 
                                          do_lower_case=True)
                                          
encoded_data_train = tokenizer.batch_encode_plus(
    df[df.data_type=='train'].Title.values, 
    add_special_tokens=True, 
    return_attention_mask=True, 
    pad_to_max_length=True, 
    max_length=256, 
    return_tensors='pt'
)

encoded_data_val = tokenizer.batch_encode_plus(
    df[df.data_type=='val'].Title.values, 
    add_special_tokens=True, 
    return_attention_mask=True, 
    pad_to_max_length=True, 
    max_length=256, 
    return_tensors='pt'
)


input_ids_train = encoded_data_train['input_ids']
attention_masks_train = encoded_data_train['attention_mask']
labels_train = torch.tensor(df[df.data_type=='train'].label.values)

input_ids_val = encoded_data_val['input_ids']
attention_masks_val = encoded_data_val['attention_mask']
labels_val = torch.tensor(df[df.data_type=='val'].label.values)

dataset_train = TensorDataset(input_ids_train, attention_masks_train, labels_train)
dataset_val = TensorDataset(input_ids_val, attention_masks_val, labels_val)

BERT预训练模型

我们将每个标题视为其独特的序列，因此一个序列将被分类到五个标签中的一个（即会议）。

bert-base-uncased是一个较小的预训练模型。
使用num_labels来指示输出标签的数量。
我们实际上不关心output_attentions。
我们也不需要output_hidden_states。

model = BertForSequenceClassification.from_pretrained("bert-base-uncased",num_labels=len(label_dict),output_attentions=False,output_hidden_states=False)

数据加载器

数据加载器结合了数据集和采样器，并提供对给定数据集的可迭代方式。

我们在训练中使用RandomSampler，而在验证中使用SequentialSampler。

考虑到我的环境内存有限，我将batch_size设置为3。

from torch.utils.data import DataLoader, RandomSampler, SequentialSampler

batch_size = 3

dataloader_train = DataLoader(dataset_train, sampler=RandomSampler(dataset_train), batch_size=batch_size)

dataloader_validation = DataLoader(dataset_val, sampler=SequentialSampler(dataset_val), batch_size=batch_size)

优化器和调度器

要构建一个优化器，我们必须给它一个包含要优化的参数的可迭代对象。然后，我们可以指定特定于优化器的选项，如学习率、epsilon等。

我发现对于这个数据集，epochs=5效果很好。

创建一个调度器，其中学习率从优化器中设置的初始学习率线性减小到0，在一个热身期之后，在热身期内，学习率从0线性增加到优化器中设置的初始学习率。

from transformers import AdamW, get_linear_schedule_with_warmup

optimizer = AdamW(model.parameters(),lr=1e-5, eps=1e-8)
                  
epochs = 5

scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0,num_training_steps=len(dataloader_train)*epochs)

性能指标

我们将使用每个类别的F1分数和准确率作为性能指标。

from sklearn.metrics import f1_score

def f1_score_func(preds, labels):
    preds_flat = np.argmax(preds, axis=1).flatten()
    labels_flat = labels.flatten()
    return f1_score(labels_flat, preds_flat, average='weighted')

def accuracy_per_class(preds, labels):
    label_dict_inverse = {v: k for k, v in label_dict.items()}
    
    preds_flat = np.argmax(preds, axis=1).flatten()
    labels_flat = labels.flatten()

    for label in np.unique(labels_flat):
        y_preds = preds_flat[labels_flat==label]
        y_true = labels_flat[labels_flat==label]
        print(f'Class: {label_dict_inverse[label]}')
        print(f'Accuracy: {len(y_preds[y_preds==label])}/{len(y_true)}\n')

训练循环

import random

seed_val = 17
random.seed(seed_val)
np.random.seed(seed_val)
torch.manual_seed(seed_val)
torch.cuda.manual_seed_all(seed_val)

def evaluate(dataloader_val):

    model.eval()
    
    loss_val_total = 0
    predictions, true_vals = [], []
    
    for batch in dataloader_val:
        
        inputs = {'input_ids':      batch[0],
                  'attention_mask': batch[1],
                  'labels':         batch[2],
                 }

        with torch.no_grad():        
            outputs = model(**inputs)
            
        loss = outputs[0]
        logits = outputs[1]
        loss_val_total += loss.item()

        logits = logits.detach().cpu().numpy()
        label_ids = inputs['labels'].cpu().numpy()
        predictions.append(logits)
        true_vals.append(label_ids)
    
    loss_val_avg = loss_val_total/len(dataloader_val) 
    
    predictions = np.concatenate(predictions, axis=0)
    true_vals = np.concatenate(true_vals, axis=0)
            
    return loss_val_avg, predictions, true_vals
    
for epoch in tqdm(range(1, epochs+1)):
    
    model.train()
    
    loss_train_total = 0

    progress_bar = tqdm(dataloader_train, desc='Epoch {:1d}'.format(epoch), leave=False, disable=False)
    for batch in progress_bar:

        model.zero_grad()
        
        batch = tuple(b.to(device) for b in batch)
        
        inputs = {'input_ids':      batch[0],
                  'attention_mask': batch[1],
                  'labels':         batch[2],
                 }       

        outputs = model(**inputs)
        
        loss = outputs[0]

        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)

        optimizer.step()
        scheduler.step()
        
        progress_bar.set_postfix({'training_loss': '{:.3f}'.format(loss.item()/len(batch))})
         
        
    torch.save(model.state_dict(), f'data_volume/finetuned_BERT_epoch_{epoch}.model')
        
    tqdm.write(f'\nEpoch {epoch}')
    
    loss_train_avg = loss_train_total/len(dataloader_train)            
    tqdm.write(f'Training loss: {loss_train_avg}')
    
    val_loss, predictions, true_vals = evaluate(dataloader_validation)
    val_f1 = f1_score_func(predictions, true_vals)
    tqdm.write(f'Validation loss: {val_loss}')
    tqdm.write(f'F1 Score (Weighted): {val_f1}')

加载和评估模型

model = BertForSequenceClassification.from_pretrained("bert-base-uncased",
                                                      num_labels=len(label_dict),
                                                      output_attentions=False,
                                                      output_hidden_states=False)

model.to(device)

model.load_state_dict(torch.load('data_volume/finetuned_BERT_epoch_1.model', map_location=torch.device('cpu')))

_, predictions, true_vals = evaluate(dataloader_validation)
accuracy_per_class(predictions, true_vals)