📝个人主页🌹：Eternity._
🌹🌹期待您的关注 🌹🌹
概述
在之前的文章中，我们介绍了BERT模型。BERT作为一种预训练语言模型，它具有很好的兼容性，能够运用在各种下游任务中，本文的主要目的是利用数据集来对BERT进行训练，从而实现一个语义分类的模型。
本文所涉及的所有资源的获取方式：这里
语义分类
语义分类是自然语言处理任务中的一种，包含文本分类、情感分析
文本分类
文本分类是指给定文本a，将文本分类为n个类别中的一个或多个。常见的应用包括文本话题分类，情感分类，具体的分类方向有有二分类，多分类和多标签分类。
文本分类可以采用传统机器学习方法（贝叶斯，svm等）和深度学习方法（fastText，TextCNN等）实现。
举例而言，对于一个对话数据集，我们可以用1、2、3表示他们的话题，如家庭、学校、工作等，而文本分类的目的，则是把这些文本的话题划分到给定的三种类别中。
情感分类
情感分析是自然语言处理中常见的场景，比如商品评价等。通过情感分析，可以挖掘产品在各个维度的优劣。情感分类其实也是一种特殊的文本分类，只是他更聚焦于情感匹配词典。
举例而言，情感分类可以用0/1表示负面评价/正面评价，例子如下：
0,不好的，319房间有故臭味。要求换房说满了，我是3月去的。在路上认识了一个上海人，他说他退房前也住的319，也是一股臭味。而且这个去不掉，特别是晚上，很浓。不知道是厕所的还是窗外的。服务一般，门前有绿皮公交去莫高窟，不过敦煌宾馆也有，下次住敦煌宾馆。再也不住这个酒店了，热水要放半个小时才有。
1,不错的酒店，大堂和餐厅的环境都不错。但由于给我的是一间走廊尽头的房间，所以房型看上去有点奇怪。客厅和卧室是连在一起的，面积偏小。服务还算到位，总的来说，性价比还是不错的。
本文将以情感二分类为例，实现如何利用BERT进行语义分析。
实现原理
首先，基于BERT预训练模型，能将一个文本转换成向量，作为模型的输入。
在BERT预训练模型的基础上，新增一个全连接层，将输入的向量通过训练转化成一个tensor作为输出，其中这个tensor的维度则是需要分类的种类，具体的值表示每个种类的概率。例如：
[0.25,0.75]
指代的是有0.25的概率属于第一类，有0.75的概率属于第二类，因此，理论输出结果是把该文本分为第二类。
核心逻辑
pre_deal.py
import csv
import random
from datasets import load_dataset
def read_file(file_path):
csv_reader = csv.reader(open(file_path, encoding='UTF-8'))
num = 0
data = []
for row in csv_reader:
if num == 0:
num = 1
continue
comment_data = [row[1], int(row[0])]
if len(comment_data[0]) > 500:
text=comment_data[0]
sub_texts, start, length = [], 0, len(text)
while start < length:
piecedata=[text[start: start + 500], comment_data[1]]
data.append(piecedata)
start += 500
else:
data.append(comment_data)
random.shuffle(data)
return data
对输入的csv文件进行处理，其中我们默认csv文件的格式是[label,text]，将用于训练的内容读取出来，转化为numpy格式，其中，如果遇到有些文本过长（超过模型的输入），将其截断，分为多个文本段来输入。在最后，会通过shuffle函数进行打乱。
train.py
train.py定义了几个函数，用于训练。
首先是Bertmodel类，定义了基于Bert的训练模型：
class Bertmodel(nn.Module):
def __init__(self, output_dim, model_path):
super(Bertmodel, self).__init__()
# 导入bert模型
self.bert = BertModel.from_pretrained(model_path)
# 外接全连接层
self.layer1 = nn.Linear(768, output_dim)
def forward(self, tokens):
res = self.bert(**tokens)
res = self.layer1(res[1])
res = res.softmax(dim=1)
return res
该模型由Bert和一个全连接层组成，最后经过softmax激活函数。
其次是一个评估函数，用来计算模型结果的准确性
def evaluate(net, comments_data, labels_data, device, tokenizer):
ans = 0 # 输出结果
i = 0
step = 8 # 每轮一次读取多少条数据
tot = len(comments_data)
while i <= tot:
print(i)
comments = comments_data[i: min(i + step, tot)]
tokens_X = tokenizer(comments, padding=True, truncation=True, return_tensors='pt').to(device=device)
res = net(tokens_X) # 获得到预测结果
y = torch.tensor(labels_data[i: min(i + step, tot)]).reshape(-1).to(device=device)
ans += (res.argmax(axis=1) == y).sum()
i += step
return ans / tot
原理就是，将文本转化为tokens，输入给模型，而后利用返回的结果，计算准确性
下面展示了开始训练的主函数，在训练的过程中，进行后向传播，储存checkpoints模型
def training(net, tokenizer, loss, optimizer, train_comments, train_labels, test_comments, test_labels,
device, epochs):
max_acc = 0.5 # 初始化模型最大精度为0.5
for epoch in tqdm(range(epochs)):
step = 8
i, sum_loss = 0, 0
tot=len(train_comments)
while i < tot:
comments = train_comments[i: min(i + step, tot)]
tokens_X = tokenizer(comments, padding=True, truncation=True, return_tensors='pt').to(device=device)
res = net(tokens_X)
y = torch.tensor(train_labels[i: min(i + step, len(train_comments))]).reshape(-1).to(device=device)
optimizer.zero_grad() # 清空梯度
l = loss(res, y) # 计算损失
l.backward() # 后向传播
optimizer.step() # 更新梯度
sum_loss += l.detach() # 累加损失
i += step
train_acc = evaluate(net, train_comments, train_labels)
test_acc = evaluate(net, test_comments, test_labels)
print('\n--epoch', epoch + 1, '\t--loss:', sum_loss / (len(train_comments) / 8), '\t--train_acc:', train_acc,
'\t--test_acc', test_acc)
# 保存模型参数，并重设最大值
if test_acc > max_acc:
# 更新历史最大精确度
max_acc = test_acc
# 保存模型
max_acc = test_acc
torch.save({
'epoch': epoch,
'state_dict': net.state_dict(),
'optimizer': optimizer.state_dict()
}, 'model/checkpoint_net.pth')
训练结果表示如下：
--epoch 0 --train_acc: tensor(0.6525, device='cuda:1') --test_acc tensor(0.6572, device='cuda:1')
0%| | 0/20 [00:00<?, ?it/s]
5%|▌ | 1/20 [01:48<34:28, 108.88s/it]
10%|█ | 2/20 [03:38<32:43, 109.10s/it]
15%|█▌ | 3/20 [05:27<30:56, 109.20s/it]
20%|██ | 4/20 [07:15<29:02, 108.93s/it]
25%|██▌ | 5/20 [09:06<27:23, 109.58s/it]
30%|███ | 6/20 [10:55<25:29, 109.26s/it]
35%|███▌ | 7/20 [12:44<23:40, 109.28s/it]
40%|████ | 8/20 [14:33<21:51, 109.29s/it]
45%|████▌ | 9/20 [16:23<20:04, 109.49s/it]
50%|█████ | 10/20 [18:13<18:15, 109.59s/it]
55%|█████▌ | 11/20 [20:03<16:27, 109.72s/it]
60%|██████ | 12/20 [21:52<14:35, 109.45s/it]
65%|██████▌ | 13/20 [23:41<12:45, 109.35s/it]
70%|███████ | 14/20 [25:30<10:54, 109.14s/it]
75%|███████▌ | 15/20 [27:19<09:05, 109.03s/it]
80%|████████ | 16/20 [29:07<07:15, 108.84s/it]
85%|████████▌ | 17/20 [30:56<05:26, 108.86s/it]
90%|█████████ | 18/20 [32:44<03:37, 108.75s/it]
95%|█████████▌| 19/20 [34:33<01:48, 108.73s/it]
100%|██████████| 20/20 [36:22<00:00, 108.71s/it]
100%|██████████| 20/20 [36:22<00:00, 109.11s/it]
--epoch 1 --loss: tensor(1.2426, device='cuda:1') --train_acc: tensor(0.6759, device='cuda:1') --test_acc tensor(0.6789, device='cuda:1')
--epoch 2 --loss: tensor(1.0588, device='cuda:1') --train_acc: tensor(0.8800, device='cuda:1') --test_acc tensor(0.8708, device='cuda:1')
--epoch 3 --loss: tensor(0.8543, device='cuda:1') --train_acc: tensor(0.8988, device='cuda:1') --test_acc tensor(0.8887, device='cuda:1')
--epoch 4 --loss: tensor(0.8208, device='cuda:1') --train_acc: tensor(0.9111, device='cuda:1') --test_acc tensor(0.8990, device='cuda:1')
--epoch 5 --loss: tensor(0.8024, device='cuda:1') --train_acc: tensor(0.9206, device='cuda:1') --test_acc tensor(0.9028, device='cuda:1')
--epoch 6 --loss: tensor(0.7882, device='cuda:1') --train_acc: tensor(0.9227, device='cuda:1') --test_acc tensor(0.9024, device='cuda:1')
--epoch 7 --loss: tensor(0.7749, device='cuda:1') --train_acc: tensor(0.9288, device='cuda:1') --test_acc tensor(0.9036, device='cuda:1')
--epoch 8 --loss: tensor(0.7632, device='cuda:1') --train_acc: tensor(0.9352, device='cuda:1') --test_acc tensor(0.9061, device='cuda:1')
--epoch 9 --loss: tensor(0.7524, device='cuda:1') --train_acc: tensor(0.9421, device='cuda:1') --test_acc tensor(0.9090, device='cuda:1')
--epoch 10 --loss: tensor(0.7445, device='cuda:1') --train_acc: tensor(0.9443, device='cuda:1') --test_acc tensor(0.9103, device='cuda:1')
--epoch 11 --loss: tensor(0.7397, device='cuda:1') --train_acc: tensor(0.9480, device='cuda:1') --test_acc tensor(0.9128, device='cuda:1')
--epoch 12 --loss: tensor(0.7321, device='cuda:1') --train_acc: tensor(0.9505, device='cuda:1') --test_acc tensor(0.9123, device='cuda:1')
--epoch 13 --loss: tensor(0.7272, device='cuda:1') --train_acc: tensor(0.9533, device='cuda:1') --test_acc tensor(0.9140, device='cuda:1')
--epoch 14 --loss: tensor(0.7256, device='cuda:1') --train_acc: tensor(0.9532, device='cuda:1') --test_acc tensor(0.9111, device='cuda:1')
--epoch 15 --loss: tensor(0.7186, device='cuda:1') --train_acc: tensor(0.9573, device='cuda:1') --test_acc tensor(0.9123, device='cuda:1')
--epoch 16 --loss: tensor(0.7135, device='cuda:1') --train_acc: tensor(0.9592, device='cuda:1') --test_acc tensor(0.9136, device='cuda:1')
--epoch 17 --loss: tensor(0.7103, device='cuda:1') --train_acc: tensor(0.9601, device='cuda:1') --test_acc tensor(0.9128, device='cuda:1')
--epoch 18 --loss: tensor(0.7091, device='cuda:1') --train_acc: tensor(0.9590, device='cuda:1') --test_acc tensor(0.9086, device='cuda:1')
--epoch 19 --loss: tensor(0.7084, device='cuda:1') --train_acc: tensor(0.9626, device='cuda:1') --test_acc tensor(0.9123, device='cuda:1')
--epoch 20 --loss: tensor(0.7038, device='cuda:1') --train_acc: tensor(0.9628, device='cuda:1') --test_acc tensor(0.9107, device='cuda:1')
最终训练结果，在训练集上达到了96.28%的准确率，在测试集上达到了91.07%的准确率
test_demo.py
这个函数提供了一个调用我们储存的checkpoint模型来进行预测的方式，将input转化为berttokens，而后输入给模型，返回输出结果。
input_text=['这里环境很好，风光美丽，下次还会再来的。']
Bert_model_path = 'xxxx'
output_path='xxxx'
device = torch.device('cpu')
checkpoint = torch.load(output_path,map_location='cpu')
model = Bertmodel(output_dim=2,model_path=Bert_model_path)
model.load_state_dict(checkpoint,False)
# print(model)
tokenizer = BertTokenizer.from_pretrained(Bert_model_path,model_max_length=512)
tokens_X = tokenizer(input_text, padding=True, truncation=True, return_tensors='pt').to(device='cpu')
model.eval()
output=model(tokens_X)
print(output)
out = torch.unsqueeze(output.argmax(dim=1), dim=1)
result = out.numpy()
print(result)
if result[0][0]==1:
print("positive")
else:
print("negative")
实现方式&演示效果
训练阶段
首先找到能够拿来训练的数据，运行pre_deal.py进行预处理，而后可以在main.py修改模型的相关参数，运行main.py开始训练。
这个过程，可能会收到硬件条件的影响，推荐使用cuda进行训练。如果实在训练不了，可以直接调用附件中对应的训练好的模型来进行预测。
测试阶段
运行test_demo.py，测试输入文本的分类结果
输入
input_text=['这里环境很好，风光美丽，下次还会再来的。']
输出
tensor([[0.3191, 0.6809]], grad_fn=<SoftmaxBackward0>)
[[1]]
positive
得出，这句话的情感分类是positive（正面）
编程未来，从这里启航！解锁无限创意，让每一行代码都成为你通往成功的阶梯，帮助更多人欣赏与学习！
更多内容详见：这里