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

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

今天，我们将尝试使用 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()
1
2
3
4
5
6
7
8
9
10

df['Conference'].value_counts()
1

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

对标签进行编码

possible_labels = df.Conference.unique()

label_dict = {}
for index, possible_label in enumerate(possible_labels):
    label_dict[possible_label] = index
label_dict
1
2
3
4
5
6

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

训练和验证集划分

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

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

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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)
1

数据加载器

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

我们在训练中使用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)
1
2
3
4
5
6
7

优化器和调度器

要构建一个优化器，我们必须给它一个包含要优化的参数的可迭代对象。然后，我们可以指定特定于优化器的选项，如学习率、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)
1
2
3
4
5
6
7

性能指标

我们将使用每个类别的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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

训练循环

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}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

加载和评估模型

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)
1
2
3
4
5
6
7
8
9
10
11

技术交流群

前沿技术资讯、算法交流、求职内推、算法竞赛、面试交流(校招、社招、实习)等、与 10000+来自港科大、北大、清华、中科院、CMU、腾讯、百度等名校名企开发者互动交流~

我们建了NLP技术与面试交流群， 想要进交流群、需要源码&资料、提升技术的同学，可以直接加微信号：mlc2060。加的时候备注一下：研究方向 +学校/公司+CSDN，即可。然后就可以拉你进群了。

方式①、微信搜索公众号：机器学习社区，后台回复：加群
方式②、添加微信号：mlc2060，备注：技术交流

用通俗易懂方式讲解系列

• 用通俗易懂的方式讲解：自然语言处理初学者指南（附1000页的PPT讲解）
• 用通俗易懂的方式讲解：1.6万字全面掌握 BERT
• 用通俗易懂的方式讲解：NLP 这样学习才是正确路线
• 用通俗易懂的方式讲解：28张图全解深度学习知识！
• 用通俗易懂的方式讲解：不用再找了，这就是 NLP 方向最全面试题库
• 用通俗易懂的方式讲解：实体关系抽取入门教程
• 用通俗易懂的方式讲解：灵魂 20 问帮你彻底搞定Transformer
• 用通俗易懂的方式讲解：图解 Transformer 架构
• 用通俗易懂的方式讲解：大模型算法面经指南（附答案）
• 用通俗易懂的方式讲解：十分钟部署清华 ChatGLM-6B，实测效果超预期
• 用通俗易懂的方式讲解：内容讲解+代码案例，轻松掌握大模型应用框架 LangChain
• 用通俗易懂的方式讲解：如何用大语言模型构建一个知识问答系统
• 用通俗易懂的方式讲解：最全的大模型 RAG 技术概览
• 用通俗易懂的方式讲解：利用 LangChain 和 Neo4j 向量索引，构建一个RAG应用程序
• 用通俗易懂的方式讲解：使用 Neo4j 和 LangChain 集成非结构化知识图增强 QA
• 用通俗易懂的方式讲解：面了 5 家知名企业的NLP算法岗(大模型方向)，被考倒了。。。。。
• 用通俗易懂的方式讲解：NLP 算法实习岗，对我后续找工作太重要了！。
• 用通俗易懂的方式讲解：理想汽车大模型算法工程师面试，被问的瑟瑟发抖。。。。
• 用通俗易懂的方式讲解：基于 Langchain-Chatchat，我搭建了一个本地知识库问答系统
• 用通俗易懂的方式讲解：面试字节大模型算法岗(实习)
• 用通俗易懂的方式讲解：大模型算法岗(含实习)最走心的总结
• 用通俗易懂的方式讲解：大模型微调方法汇总